@voxgig/sdkgen 4.20.0 → 4.22.0

package/project/.sdk/tm/go/test/feature_test.go

@@ -1,15 +1,7 @@
 package sdktest
 
-// Behavioural tests for the enterprise features shipped with this SDK
-// (retry, cache, rbac, telemetry, ...). Each block runs only when its
-// feature is present (see fhSkipWithout in feature_harness_test.go, which
-// also holds the fh* pipeline harness these tests drive).
-//
-// This file constructs every shipped feature type by name, so it only
-// compiles with the COMPLETE feature set — it is listed in the go target's
-// `feature.fullset` and dropped when a project trims its features.
-
 import (
+	"encoding/json"
 	"os"
 	"reflect"
 	"regexp"
@@ -21,6 +13,112 @@ import (
 	feat "GOMODULE/feature"
 )
 
+// --- option coercion --------------------------------------------------------
+
+type fhRetries int
+
+func vsGetPath(node any, keys ...string) any {
+	cur := node
+	for _, k := range keys {
+		m, ok := cur.(map[string]any)
+		if !ok {
+			return nil
+		}
+		cur = m[k]
+	}
+	return cur
+}
+
+// go read a closed type switch and silently used the DEFAULT for any other
+// numeric type. `retry` makes the budget observable as a call count, so a
+// dropped option shows as the default of 2 rather than the 4 asked for.
+func TestFeatureOptionNumericTypes(t *testing.T) {
+	fhSkipWithout(t, "retry")
+
+	var jsonNum map[string]any
+	dec := json.NewDecoder(strings.NewReader(`{"retries":4}`))
+	dec.UseNumber()
+	if err := dec.Decode(&jsonNum); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+
+	cases := []struct {
+		name string
+		val  any
+	}{
+		{"int", 4},
+		{"int8", int8(4)},
+		{"int16", int16(4)},
+		{"int32", int32(4)},
+		{"int64", int64(4)},
+		{"uint", uint(4)},
+		{"uint8", uint8(4)},
+		{"uint16", uint16(4)},
+		{"uint32", uint32(4)},
+		{"uint64", uint64(4)},
+		{"float32", float32(4)},
+		{"float64", float64(4)},
+		{"json.Number", jsonNum["retries"]},
+		{"defined int", fhRetries(4)},
+	}
+
+	const want = 5
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			rec := &fhRecorder{reply: func(_ int, _ map[string]any) (any, error) {
+				return fhResponse(500, nil, nil), nil
+			}}
+			h := fhMake(rec.fetch, fhF(feat.NewRetryFeature(), map[string]any{
+				"retries": c.val, "minDelay": 0, "jitter": false,
+			}))
+			h.op(fhOpSpec{op: "load"})
+			if len(rec.calls) != want {
+				t.Fatalf("%s: retries was not honoured - %d call(s), want %d "+
+					"(the default budget of 2 gives 3)", c.name, len(rec.calls), want)
+			}
+		})
+	}
+
+	t.Run("survives-the-real-makeoptions", func(t *testing.T) {
+		// fhMake calls Init directly, so the cases above never meet the option
+		// VALIDATOR. To reflect a json.Number is a string, and an option the
+		// validator judges by a rule the readers do not is the same defect
+		// one layer up.
+		client := sdk.TestSDK(nil, nil)
+		utility := client.GetUtility()
+		ctx := utility.MakeContext(map[string]any{
+			"client": client, "utility": utility,
+		}, client.GetRootCtx())
+		ctx.Options = map[string]any{
+			"feature": map[string]any{
+				"retry": map[string]any{"active": true, "retries": jsonNum["retries"]},
+			},
+		}
+		ctx.Config = map[string]any{"options": map[string]any{}}
+
+		got := vsGetPath(utility.MakeOptions(ctx), "feature", "retry", "retries")
+		if n, ok := got.(int64); !ok || n != 4 {
+			t.Fatalf("MakeOptions did not canonicalise the option: %v (%T), want int64(4)", got, got)
+		}
+	})
+
+	t.Run("a-non-number-still-falls-back", func(t *testing.T) {
+		// A string is not a Number in java either.
+		rec := &fhRecorder{reply: func(_ int, _ map[string]any) (any, error) {
+			return fhResponse(500, nil, nil), nil
+		}}
+		h := fhMake(rec.fetch, fhF(feat.NewRetryFeature(), map[string]any{
+			"retries": "4", "minDelay": 0, "jitter": false,
+		}))
+		h.op(fhOpSpec{op: "load"})
+		if len(rec.calls) != 3 {
+			t.Fatalf("a string option was coerced: %d call(s), want 3 (the default budget)",
+				len(rec.calls))
+		}
+	})
+}
+
 // --- netsim -----------------------------------------------------------------
 
 func TestFeatureNetsim(t *testing.T) {

package/project/.sdk/tm/go/test/omni/omni.go

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni sdk-20260908-1556-0 (go/omni.go)
-// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+// VENDORED: @voxgig/omni sdk-20260917-1242-0 (go/omni.go)
+// Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 // Omni: the shared multi-language test runner.
 //

package/project/.sdk/tm/go/test/omni/util.go

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni sdk-20260908-1556-0 (go/util.go)
-// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260911-2013-0]
+// VENDORED: @voxgig/omni sdk-20260917-1242-0 (go/util.go)
+// Source: https://github.com/voxgig/omni @ b9e6085d185e174be84f9e6123be807ccd9fcb4e  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 // Omni internal JSON utilities.
 //

package/project/.sdk/tm/go/test/omniresolver_test.go

@@ -1,51 +1,3 @@
-// The corpus test runner: vendored @voxgig/omni driven through its NATIVE
-// API (`omni.MakeRunner(specref, provider)`), presented to the corpus tests
-// in the struct-runner shape they already use (`RunPack.Spec`,
-// `RunPack.RunSet`, `RunPack.RunSetFlags`, `RunPack.Client`). No compat
-// shim is vendored: the adapter below IS the whole bridge, per language,
-// per the vendor-tag rollout (docs/design/vendor-tag-rollout.md,
-// Decision 4). It supersedes the engine halves of the retired
-// runner_test.go and struct_runner_test.go (support lives on in
-// testsupport_test.go).
-//
-// Go-specific decisions, each load-bearing:
-//
-// 1. REFLECTION PROVIDER. The omni provider hooks reach the client by
-//    reflection over the names the clients already expose (Utility() /
-//    GetUtility(), Struct(), Contextify(), Tester()), so ONE resolver
-//    serves both the generated SDK and the struct-corpus client in
-//    struct_utility_test.go. Ported from upstream's go compat shim
-//    (omni go/compat/struct), which this resolver replaces.
-//
-// 2. CONTEXTS STAY MAPS ACROSS THE RUNNER. omni sets `entry.ctx` to the
-//    contextified args[0] and `match: {ctx: ...}` assertions read THROUGH
-//    it with omni's own GetPath, which walks JSON maps only. A typed
-//    *sdk.Context there would make every ctx assertion read "absent". So
-//    Contextify returns the MAP; a corpus subject builds the typed context
-//    with omniCtx(args[0], ...) at the call site, runs the utility, and
-//    writes the observable ctx state back into the same map with
-//    omniSyncCtx - which is what makes the live SDK reachable through
-//    ctx.Client for the generated utilities (the ts resolver gets both for
-//    free from prototype delegation; maps-plus-sync is the go idiom for
-//    the same contract).
-//
-// 3. ZERO-ARGUMENT ENTRIES (novalargs). The corpus carries entries with no
-//    `in`, `args` or `ctx`, meaning "call the subject with NO argument".
-//    omni's native rule passes [clone(entry.in)] - one null. The upstream
-//    go compat shim corrected this by handing such entries the struct
-//    port's own no-value sentinel (NOVAL); that correction is ported here
-//    (novalargs/novalsubject/NOVALMARK), not dropped.
-//
-// 4. THE VENDORED GO PORT LACKS THE omni#54 RUNNER FIXES the TypeScript
-//    port has at this tag (omni#57 tracks porting them): JsonStr has no
-//    cycle guard, and Match clones its base. Both only bite on CYCLIC
-//    values, and go's Clone/FixJson pass non-JSON values (a typed context,
-//    a client) through by reference without walking them - so decision 2
-//    above (JSON-only maps in entries, typed state kept out of them) is
-//    also what keeps every value the runner clones or stringifies acyclic.
-//    The errify half (non-Error throwables) cannot arise in go: subjects
-//    return `error` values, and the Errify hook below keeps the SDK
-//    error's code for `match: {err: {code: ...}}` assertions.
 
 package sdktest
 
@@ -86,7 +38,6 @@ type Subject = omni.Subject
 // RunSet runs one set of test entries, reporting failures to the test.
 type RunSet func(t TestingT, testspec any, testsubject any)
 
-// RunSetFlags runs one set of test entries with flags.
 type RunSetFlags func(t TestingT, testspec any, flags map[string]bool, testsubject any)
 
 // RunPack is what the runner returns for one named spec section - the
@@ -151,7 +102,6 @@ func MakeRunner(testfile any, client any) func(name string, store any) (*RunPack
 	}
 }
 
-// The runner's flags are booleans; omni's carry any value.
 func omniflags(flags map[string]bool) omni.Flags {
 	out := omni.Flags{}
 	for name, flag := range flags {
@@ -160,12 +110,6 @@ func omniflags(flags map[string]bool) omni.Flags {
 	return out
 }
 
-// providerclients maps each omni provider back to the live client it
-// wraps, and defproviders marks the ones a spec's DEF.client built - the
-// only ones omniCtx lets override a call site's explicit client (the base
-// provider rides on EVERY ctx entry, and letting it win would defeat the
-// sections that deliberately construct a differently-optioned client).
-// Guarded: corpus subtests may run concurrently.
 var (
 	providerclientsmu sync.Mutex
 	providerclients   = map[*omni.Provider]any{}
@@ -269,7 +213,6 @@ func omniProvider(client any) *omni.Provider {
 			return ctx
 		},
 
-		// Client options may reference the runner store.
 		Inject: func(options any, store any) any {
 			vs.Inject(options, store)
 			return options
@@ -298,12 +241,6 @@ func omniProvider(client any) *omni.Provider {
 	return provider
 }
 
-// utilityof reaches the client's utility: Utility() on the struct corpus
-// client, GetUtility() on the generated SDK. Only a ZERO-ARGUMENT method
-// counts - a generated SDK with an entity named `utility` has an entity
-// ACCESSOR of the same name that takes options, and calling that here
-// would panic (the fixture model ships reserved-name entities precisely to
-// catch this class of collision).
 func utilityof(client any) reflect.Value {
 	method := findnullarymethod(reflect.ValueOf(client), "utility")
 	if !method.IsValid() {
@@ -452,9 +389,6 @@ func novalargs(testspec any, sentinel any) (any, bool) {
 	return out, true
 }
 
-// NOVALMARK stands in for the port's no-value between novalargs and
-// novalsubject. Deliberately not one of omni's own sentinels: those are
-// meaningful to the runner, and this one must pass through it inert.
 const NOVALMARK = "__OMNIRESOLVER_NOVAL__"
 
 // novalsubject swaps the marker back for the real sentinel at the point of
@@ -490,12 +424,6 @@ func noargs(entry any) bool {
 	return true
 }
 
-// fixnums: an integral JSON number becomes a Go `int`, on both the spec
-// and the result side. The struct port's API is written in `int`
-// (`Typename(t int)`, `Flatten(list, depths ...int)`), and omni's go
-// runner keeps JSON numbers as float64 - handing a subject a type its
-// signature rejects. omni's DeepEqual compares numbers by value, so the
-// normalisation is invisible to assertions.
 func fixnums(val any) any {
 	switch value := val.(type) {
 	case float64:
@@ -641,7 +569,6 @@ func omniCtx(arg any, client *sdk.ProjectNameSDK, utility *sdk.Utility) *sdk.Con
 		ctx.Spec = sdk.NewSpec(specMap)
 	}
 
-	// Handle result from JSON map
 	if resMap, ok := ctxmap["result"].(map[string]any); ok {
 		ctx.Result = sdk.NewResult(resMap)
 		if errMap, ok := resMap["err"].(map[string]any); ok {
@@ -651,7 +578,6 @@ func omniCtx(arg any, client *sdk.ProjectNameSDK, utility *sdk.Utility) *sdk.Con
 		}
 	}
 
-	// Handle response from JSON map
 	if respMap, ok := ctxmap["response"].(map[string]any); ok {
 		ctx.Response = sdk.NewResponse(respMap)
 		if body := respMap["body"]; body != nil {

package/project/.sdk/tm/go/test/omnismoke_test.go

@@ -1,7 +1,3 @@
-// Smoke tests for the vendored omni runner itself: a runner that cannot
-// FAIL a bad entry would turn every corpus suite vacuously green, so pin
-// the failure paths, not just the happy one. (The go peer of
-// tm/ts/test/omni.test.ts.)
 
 package sdktest
 

package/project/.sdk/tm/go/test/pipeline_test.go

@@ -1,12 +1,5 @@
 package sdktest
 
-// Direct unit tests for the operation-pipeline utilities. The generated
-// entity tests exercise the happy path; these drive the error and edge
-// branches (missing spec/response/result, 4xx handling, transport
-// failures, feature add semantics, auth header shaping) that a normal
-// success-path op never reaches. All utilities are reached through the
-// client utility, so this suite is API-agnostic. Reuses the fh* helpers
-// from feature_test.go (same package).
 
 import (
 	"testing"
@@ -417,9 +410,6 @@ func TestPipelineFeatureAdd(t *testing.T) {
 	})
 }
 
-// Feature #2: options.feature accepts an ordered ARRAY (developer add-order)
-// or a map (defaults test-first); MakeOptions records the resolved order in
-// __derived__.featureorder.
 func TestPipelineFeatureOrder(t *testing.T) {
 	resolve := func(feature any) string {
 		client, utility := plClient(t, nil)

package/project/.sdk/tm/go/test/primary_utility_test.go

@@ -11,8 +11,6 @@ import (
 	vs "github.com/voxgig/struct"
 )
 
-// PENDING sections are the ones deliberately left empty in the shared corpus
-// (.sdk/test/primary/<name>.aon). Everything else MUST contribute cases.
 var pendingSections = map[string]bool{
 	"fetcher": true, "makeFetchDef": true, "makeResult": true,
 	"featureAdd": true, "featureHook": true, "featureInit": true,
@@ -37,12 +35,6 @@ func TestPrimaryUtility(t *testing.T) {
 		t.Fatal("primary section not found in test.json")
 	}
 
-	// Run one corpus section, failing loudly when it would run ZERO cases.
-	// A renamed section, a fixture that failed to compile, or an empty set
-	// used to report PASS while running zero assertions - the whole point
-	// of a shared oracle lost without a single red test. (The guard lives
-	// here rather than in the runner, which is vendored verbatim; the
-	// shared corpus is a v0 spec, and v0 tolerates an empty set.)
 	runsection := func(t *testing.T, name string, subject any) {
 		t.Helper()
 		section, _ := primary[name].(map[string]any)
@@ -283,9 +275,6 @@ func TestPrimaryUtility(t *testing.T) {
 	t.Run("fetcher-live", func(t *testing.T) {
 		calls := []map[string]any{}
 		liveClient := sdk.NewProjectNameSDK(map[string]any{
-			// Concrete base: a live construction must satisfy any server
-			// variables a templated base URL declares; a literal base
-			// sidesteps the requirement.
 			"base": "http://localhost:8080",
 			"system": map[string]any{
 				"fetch": func(url string, fetchdef map[string]any) (map[string]any, error) {
@@ -553,16 +542,6 @@ func TestPrimaryUtility(t *testing.T) {
 		})
 	})
 
-	// Was one hand-written case (the single-point path) covering one of this
-	// utility's seven branches, which is how the corpus fixture came to be
-	// marked deferred as "needs a real client". It does not: NewContext
-	// rebuilds Op from opname + entity + config, and Options can be supplied
-	// literally. Driven from the corpus now, so TS and Go assert the same
-	// branches.
-	//
-	// TS returns the error AS the value; Go returns it as a second result. The
-	// corpus says `match: out: code` for both, so the error is normalised to a
-	// map carrying its code here rather than forking the fixture per language.
 	t.Run("makePoint-basic", func(t *testing.T) {
 		runsection(t, "makePoint", func(args ...any) (any, error) {
 			ctxmap, _ := args[0].(map[string]any)
@@ -570,12 +549,6 @@ func TestPrimaryUtility(t *testing.T) {
 				ctxmap = map[string]any{}
 			}
 
-			// NewContext resolves Op from the ENTITY NAME, and reaches it
-			// through the Entity interface - a literal {name:...} map from the
-			// fixture is not one, so entname would be "" and every lookup would
-			// miss, reporting point_no_points for all seven cases. TS reads the
-			// same field with getprop and accepts the plain map. Swap in the
-			// package's minimal Entity so both ports resolve the same op.
 			if em, ok := ctxmap["entity"].(map[string]any); ok {
 				name, _ := em["name"].(string)
 				made := []any{}
@@ -634,7 +607,6 @@ func TestPrimaryUtility(t *testing.T) {
 
 			result := utility.Param(ctx, paramdef)
 
-			// The spec alias mutation is what mark 80 asserts on.
 			omniSyncCtx(args[0], ctx)
 
 			return result, nil
@@ -695,10 +667,6 @@ func TestPrimaryUtility(t *testing.T) {
 		})
 	})
 
-	// Was two hand-written cases that had drifted out of the shared corpus
-	// (the preparePath fixture shipped as an empty `set: []`). Now driven by
-	// the corpus like every other section, so all ports assert the same
-	// separator/blank-segment behaviour.
 	t.Run("preparePath-basic", func(t *testing.T) {
 		runsection(t, "preparePath", func(args ...any) (any, error) {
 			ctx := omniCtx(args[0], client, utility)

package/project/.sdk/tm/go/test/struct_utility_test.go

@@ -1,6 +1,3 @@
-// Vendored from github.com/voxgig/struct/go/voxgigstruct_test.go
-// RUN: go test
-// RUN-SOME: go test -v -run=TestStructUtility/getpath
 
 package sdktest
 
@@ -160,13 +157,6 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("minor-escurl", func(t *testing.T) {
-		// Passed BARE, like every other minor subject. This used to wrap
-		// EscUrl in ReplaceAll(..., "+", "%20") because the vendored copy
-		// implemented it with net/url.QueryEscape, which form-encodes: a
-		// space became '+' rather than '%20'. The workaround made the
-		// shared corpus pass while make_url.go still emitted '+' into real
-		// paths and query strings. Upstream's EscUrl matches the reference
-		// encodeURIComponent exactly, so there is nothing left to paper over.
 		structRunSet(t, minorSpec["escurl"], voxgigstruct.EscUrl)
 	})
 
@@ -179,21 +169,6 @@ func TestStructUtility(t *testing.T) {
 				val = "null"
 			}
 
-			// Go has no `undefined`. Upstream Stringify renders nil as
-			// "null" ON PURPOSE - in Go nil IS JSON null, and
-			// JSON.stringify(null) is "null" - so the corpus's two
-			// separate cases,
-			//
-			//   {"val": null} -> "null"      and      {} -> ""
-			//
-			// both arrive here as a nil val and cannot be told apart by
-			// VALUE. They can be told apart by PRESENCE: the second case
-			// is the JavaScript stringify(undefined), and an absent key
-			// is the only thing Go has that means undefined.
-			//
-			// The runner is the right place for this: it is the seam
-			// between a language-neutral corpus and one language's type
-			// system, and it already bridges the same gap for pathify.
 			if !hasVal {
 				return ""
 			}
@@ -658,12 +633,6 @@ func TestStructUtility(t *testing.T) {
 				ks = *k
 			}
 
-			// The ROOT node has no parent. The reference passes
-			// `undefined` there and logs `p=`; Go has only nil, which
-			// Stringify renders as "null" (its documented choice - see
-			// minor-stringify above). Rendering the absent parent as ""
-			// keeps the log identical to the reference's, which is what
-			// the corpus records.
 			ps := ""
 			if nil != p {
 				ps = voxgigstruct.Stringify(p)
@@ -1506,13 +1475,6 @@ func IsSameFunc(target any, candidate any) bool {
 	return reflect.ValueOf(target).Pointer() == reflect.ValueOf(candidate).Pointer()
 }
 
-// ---------------------------------------------------------------------
-// Struct-corpus SUPPORT, retained from the retired struct_runner_test.go
-// (its engine half is superseded by the vendored omni runner driven
-// through omniresolver_test.go). The StructSDK below is the client the
-// runner wraps for the struct sections; NullModifier names struct's own
-// *voxgigstruct.Injection and so cannot live in the language-neutral
-// resolver; Fdt/ToJSONString are debug helpers, not runner API.
 
 type StructUtility struct {
 	IsNode     func(val any) bool

package/project/.sdk/tm/go/test/testsupport_test.go

@@ -1,11 +1,3 @@
-// SDK test SUPPORT: the helpers the generated entity/direct tests and the
-// corpus call sites share - env loading, the sdk-test-control.json skip and
-// pacing machinery, corpus access, and entity-data conversion.
-//
-// Split out of the retired runner_test.go (vendor-tag rollout: the corpus
-// ENGINE half of that file is superseded by the vendored omni runner driven
-// through the resolver in omniresolver_test.go; this support half is
-// retained). Same package, same names - the emitted call sites did not move.
 
 package sdktest
 
@@ -159,23 +151,6 @@ func isControlSkipped(kind, name, mode string) (bool, string) {
 	return false, ""
 }
 
-// liveDelayMs returns the configured per-test live delay in ms; default 500.
-// liveClientOptions returns the extra SDK options every LIVE client is
-// constructed with, from sdk-test-control.json `test.client.options`.
-//
-// The generated live client knows two things: the base URL (from the spec)
-// and the credential (from the environment). Everything else about how a
-// particular API wants to be talked to - which features to switch on, and
-// with what settings - is a property of THAT API, known to the project and
-// to nothing in the toolchain.
-//
-// Merged UNDER the generated fields, so the suite's own base/apikey/server
-// values win: this ADDS to the live client, it does not redirect it.
-//
-// That contract is enforced HERE rather than left to each merge site: the
-// generated map only names a field when the model calls for one, so a
-// "base" in this block would face no competing value and would silently
-// redirect the whole suite - credential included - to another host.
 var liveReserved = map[string]bool{
 	"base": true, "prefix": true, "suffix": true,
 	"server": true, "apikey": true, "secret": true,

package/project/.sdk/tm/go/utility/feature_add.go

@@ -2,12 +2,6 @@ package utility
 
 import "GOMODULE/core"
 
-// featureAddUtil appends a feature to the client's feature list. A feature
-// that implements AddOptions (every BaseFeature embedder does, via the
-// AddOpts field) can instead position itself relative to an already-added
-// feature with "__before__", "__after__" or "__replace__" naming that
-// feature — mirroring the ts featureAdd. The first match wins; when no
-// ordering option matches, the feature is appended.
 func featureAddUtil(ctx *core.Context, f core.Feature) {
 	client := ctx.Client
 	features := client.Features

package/project/.sdk/tm/go/utility/fetcher.go

@@ -57,12 +57,6 @@ func defaultHTTPFetch(fullurl string, fetchdef map[string]any) (map[string]any,
 		}
 	}
 
-	// Honour a redirect annotation: "manual" surfaces a 3xx as an ordinary
-	// response instead of auto-following it. In the ts/js targets fetchdef
-	// rides straight into fetch(), where `redirect` is a native option -
-	// this is the same seam for Go's auto-following http.Client. The
-	// station feature sets it under a hosts egress policy, so a Location
-	// off the allowlist cannot pull an automatic credentialed follow-up.
 	if redirect, ok := fetchdef["redirect"].(string); ok && redirect == "manual" {
 		manual := *client
 		manual.CheckRedirect = func(req *http.Request, via []*http.Request) error {

package/project/.sdk/tm/go/utility/graphql.go

@@ -9,22 +9,7 @@ import (
 	"GOMODULE/core"
 )
 
-// GraphQL transport. API-INDEPENDENT: every GraphQL SDK this generator
-// produces uses this file unchanged. The API-specific part — which
-// operations exist and what each one's document is — is model data,
-// computed once by apidef and emitted into Config.
-//
-// Two jobs:
-//
-//	GraphqlBody   — build { query, variables } for a point, binding the
-//	                op's arguments to the document's declared variables.
-//
-//	GraphqlErrors — lift a GraphQL failure into an SDK error. GraphQL
-//	                reports failures as a top-level `errors` array under
-//	                HTTP 200, so the status-driven path in resultBasic
-//	                never sees them.
-
-// Content type every GraphQL-over-HTTP request uses.
+
 const GraphqlContentType = "application/json"
 
 // Map a GraphQL error to the same error codes the HTTP path produces, so a
@@ -56,12 +41,6 @@ func graphqlErrorCodeUtil(gqlerr any) string {
 	return "request_graphql"
 }
 
-// Build the request body for a GraphQL point.
-//
-// Variables come from the op's own arguments: a named variable binds to the
-// like-named argument (`from`), and the input-object variable (empty `from`)
-// takes the request data as a whole — which is what makes a generated
-// create/update call look exactly like its REST equivalent.
 func graphqlBodyUtil(ctx *core.Context) any {
 	gql, _ := vs.GetProp(ctx.Point, "graphql").(map[string]any)
 	if gql == nil {
@@ -110,8 +89,6 @@ func graphqlBodyUtil(ctx *core.Context) any {
 			continue
 		}
 
-		// Only send variables the caller actually supplied: sending an
-		// explicit null would clear a field on many APIs.
 		val := vs.GetProp(reqsrc, from)
 		if val == nil {
 			val = vs.GetProp(datasrc, from)
@@ -129,13 +106,6 @@ func graphqlBodyUtil(ctx *core.Context) any {
 	}
 }
 
-// Inspect a decoded GraphQL response body and record a failure when the
-// server reported one. Returns true when an error was recorded.
-//
-// Partial data (`data` alongside `errors`) is treated as failure: the REST
-// surface has no partial-success concept, and silently returning half an
-// object would be worse than failing. The raw envelope stays available on
-// the result for callers that need it.
 func graphqlErrorsUtil(ctx *core.Context) bool {
 	if ctx.Result == nil || ctx.Point == nil {
 		return false