What

Three commits that make the core types library-friendly: after this PR, anything with an engine connection can marshal, unmarshal, and build on Dagger objects through the published dagger.io/dagger API alone — no generated package-local state required. This is the foundation for the Go codegen v2 proposal (related: #11417, #11547): sharing core types via dagger.io/dagger instead of regenerating them under internal/dagger in every module. Behavior of existing modules is unchanged.

Commit 1 — explicit marshal/unmarshal seam

Generated code currently resolves objects to IDs (and back) through package-level globals — marshalCtx and dag — set once per dispatch via SetMarshalContext. This commit makes the dependencies explicit, in all codegen modes (library, module, standalone client):

• IDClient — the minimal client surface needed to reconstruct objects from IDs (QueryBuilder(), GraphQLClient()). *Client already satisfies it in all three modes.
• MarshalJSON(ctx, v) — marshals v, scoping the ID-resolution context to the single call (mutex-guarded swap of marshalCtx).
• UnmarshalJSON(c, data, v) (module mode) — unmarshals data, reconstructing objects through the given client (mutex-guarded swap of dag).

The generated module dispatch now calls these with its ctx/dag explicitly: parent state and input args go through dagger.UnmarshalJSON(dag, ...), function results through dagger.MarshalJSON(ctx, ...). SetMarshalContext remains (deprecated) so user code that calls json.Marshal directly on Dagger objects keeps resolving IDs with the dispatch context.

Commit 2 — json/v2 Marshalers/Unmarshalers

Builds on IDClient to generate json/v2 marshaler/unmarshaler sets that carry their context/client in closures:

data, err := json.Marshal(v, json.WithMarshalers(dagger.Marshalers(ctx)))
err = json.Unmarshal(data, &v, json.WithUnmarshalers(dagger.Unmarshalers(dag)))

Unlike the v1 per-type methods, these need no methods on the types and no globals, are safe with multiple clients in one process, and bring ID-based unmarshaling to the library and standalone-client modes for the first time (previously module-only).

Two implementations rendered from one template body, selected by the goexperiment.jsonv2 build tag:

Once the SDK's minimum Go version reaches 1.27, the compat file and the go-json-experiment dependency can be deleted with no API change.

Nothing generated calls these yet; migrating dispatch onto them — and then deleting the per-type UnmarshalJSON methods and the marshalCtx/dag globals, which is what makes internal/dagger's core types byte-identical to the published SDK — is the follow-up PR.

Commit 3 — GraphQLQuery selection getter

Every generated object/interface type gains GraphQLQuery() *querybuilder.Selection, pairing with the existing WithGraphQLQuery setter. Together they form the public query seam: code outside the generated package (dependency bindings in portable mode, third-party integrations) can read an object's selection and build on it without network ID round-trips or access to the unexported query field. Purely additive.

Notes for reviewers

• New dependency (commit 2 only): github.com/go-json-experiment/json, pseudo-version pinned, compiled only under !goexperiment.jsonv2. It reaches module go.mods through the existing sdk-go.mod merge in bootstrapMod. If this needs separate discussion, commit 2 splits out cleanly — commit 1 stands on its own.
• Marshalers are registered on value types, unmarshalers on pointer types, mirroring v1 method semantics (nil pointers marshal as null, pointer fields are allocated on unmarshal). Enums/scalars are untouched; json/v2 falls through to their existing context-free v1 methods.
• IDClient reuses the already-exported QueryBuilder()/GraphQLClient() accessors, so any future wrapper client type satisfies it by embedding.

Test plan

• sdk/go builds under both configs (default and GOEXPERIMENT=jsonv2, Go 1.26); regenerated files match template output byte-for-byte.
• Module-mode output (all dispatch call sites + helpers) compiles against a generated-module fixture.
• Needs a maintainer/CI pass for the dagger generate round-trip and integration suite (module codegen requires an engine connection).