@voxgig/sdkgen 4.21.0 → 4.22.0

package/project/.sdk/tm/go/test/feature/secrets/secrets_feature_test.go

@@ -1,26 +1,3 @@
-// Behavioural tests for the secrets feature (vendored @voxgig/sekreto) -
-// the go port of tm/ts/test/feature/secrets/Secrets.test.ts.
-//
-// The contract under test: the `apikey` OPTION keeps its exact old meaning
-// and always wins, because SecretsFeature places it FIRST in the provider
-// chain (a `memory` store named `options`) - explicit-beats-lookup falls
-// out of sekreto's first-hit rule rather than from special-case logic.
-// With the feature inactive nothing changes at all. With it active and the
-// option unset, the chain (env, a custom provider, a vault) supplies the
-// credential instead.
-//
-// This file lives in the test `feature/` container on purpose: `target
-// add` trims it, along with the feature source and the vendored library,
-// for a project whose model does not select `secrets`.
-//
-// The feature is CONSTRUCTED DIRECTLY and handed in through the
-// `extend` option, so these tests hold in any generated tree - whether or
-// not the project's model activated the feature (activation only changes
-// whether config.go registers a constructor for it). The credential is
-// asserted ON THE WIRE: a live-mode client with a recording system.fetch,
-// driven through a real entity operation, which is what exercises the
-// PreSpec resolution seam. (See the migration guide: an options-level
-// assertion passes for a port that never consults the value.)
 
 package secretstest
 
@@ -174,13 +151,6 @@ func secretsClient(w *wire, sdkopts map[string]any) *sdk.ProjectNameSDK {
 	})
 }
 
-// withSecrets constructs the client and ADOPTS the feature via `extend`
-// ONLY when the generated config did not already install it - when this
-// SDK was generated with `secrets` model-active, the ordinary factory
-// path builds the instance, and adding a second via extend would DOUBLE
-// the feature: two transport wraps, two resolutions, and a token
-// purchase the assertions cannot account for. (The py harness guards the
-// same way via _has_feature.)
 func withSecrets(build func(extend bool) *sdk.ProjectNameSDK) *sdk.ProjectNameSDK {
 	client := build(false)
 	if nil == secretsFeatureOf(client) {
@@ -213,13 +183,6 @@ func secretsFeatureOf(client *sdk.ProjectNameSDK) *feat.SecretsFeature {
 	return nil
 }
 
-// driveEntityOpUntil performs real entity operations - which is what runs
-// the PreSpec hook - until `stop` reports the observable state a test is
-// waiting for. Each op's own outcome is irrelevant (no seeded data, a
-// scripted response); an op the API does not define fails BEFORE the
-// PreSpec hook, which is why several may need driving. Entity names come
-// from the SDK's own config, because this file is a TEMPLATE and no
-// project's entity names are known here.
 func driveEntityOpUntil(t *testing.T, client *sdk.ProjectNameSDK, what string, stop func() bool) {
 	t.Helper()
 
@@ -266,17 +229,6 @@ func exported(name string) string {
 	return string(runes)
 }
 
-// routableOp names an entity operation that actually REACHES THE TRANSPORT.
-//
-// A generated entity exposes List, Load and Create whether or not the model
-// declares them, so "drive the first entity the map yields" drives a dead
-// end whenever the model does not declare that one. Go randomises map
-// iteration, so which entity that is changes per run, and a test asserting
-// on what reached the wire then passes or fails by lottery.
-//
-// Discover a real route ONCE, against a throwaway client whose provider
-// always succeeds so nothing gates it, and drive that everywhere a test
-// needs a request to come out.
 func routableOp(t *testing.T) (string, string) {
 	t.Helper()
 
@@ -433,12 +385,6 @@ func TestSecretsChain(t *testing.T) {
 
 		driveEntityOp(t, client, w)
 
-		// Resolution happens AT THE TRANSPORT - the one seam every wire
-		// path crosses - so the credential is on the wire, not merely
-		// resolved. go holds it in FEATURE STATE and injects there; the
-		// options map is never mutated (it stays raced-read-safe for
-		// every concurrent operation), so the state assertion reads the
-		// feature.
 		credentialIs(t, w.api()[0].auth, "ENVKEY02")
 		if v := secretsFeatureOf(client).Credential(); "ENVKEY02" != v {
 			t.Fatalf("the entity op did not resolve the secret through PreSpec: %q", v)
@@ -576,15 +522,6 @@ func TestSecretsChain(t *testing.T) {
 	})
 }
 
-// A MISS IS NOT A CACHEABLE ANSWER - sekreto's own rule, which this
-// feature used to override from the layer above.
-//
-// DEFAULT caching here, which is the whole point: `cache: true` is about
-// holding a HIT, and holding the settled resolution after a miss meant the
-// chain was never asked again for the life of the client. A secret
-// provisioned after startup (a mounted file, a vault policy granted a
-// minute late) was invisible forever, and the only workaround was giving up
-// hit caching entirely.
 func TestSecretsCachedMissIsReasked(t *testing.T) {
 	var mu sync.Mutex
 	calls := 0
@@ -705,16 +642,9 @@ func TestSecretsExchange(t *testing.T) {
 			t.Fatalf("expected the request to be retried exactly once, got %d calls", len(api))
 		}
 		credentialIs(t, api[0].auth, "ACCESS01")
-		// The retry must carry the NEW token, not the spent one.
 		credentialIs(t, api[1].auth, "ACCESS02")
 	})
 
-	// `auth: nil` SUPPRESSES THE PURCHASE, not just the retry.
-	//
-	// resolve() runs before withrefresh's suppression check, so the refresh
-	// token used to go to the token endpoint in a request body even here.
-	// Stopping the retry does not unsend it - this asserts on the token
-	// endpoint, which is the half the API-call assertions cannot see.
 	t.Run("auth nil buys no token at all", func(t *testing.T) {
 		os.Setenv(envprefix+"REFRESH_TOKEN", "REFRESH01")
 		defer os.Unsetenv(envprefix + "REFRESH_TOKEN")
@@ -776,11 +706,6 @@ func TestSecretsExchange(t *testing.T) {
 	})
 }
 
-// ---------------------------------------------------------------------
-// Review-hardening pins (vendor-tag rollout, PR review): the exchange
-// works with ORDINARY options (no custom transport), the token body is
-// real JSON, an uncached miss retracts the credential, and a failed
-// resolution recovers safely under concurrency.
 
 // The exchange with NO system.fetch: the raw fallback transport carries
 // the purchase, and the body is MARSHALLED - a refresh token full of
@@ -936,23 +861,6 @@ func TestSecretsDirectPath(t *testing.T) {
 	}
 }
 
-// FAIL CLOSED ON A CONSTRUCTION FAILURE. The chain a project configures
-// can be wrong before a single lookup happens, and Init cannot fail the
-// client construction the way ts's throwing init does - so it HOLDS the
-// error (initerr) and the transport gate refuses to send.
-//
-// The entry pinned here is a bare kind name where a spec belongs. Init's
-// type switch over the providers list had cases for a *ProviderSpec, a
-// Provider and a map, and no default - so the entry was silently DROPPED,
-// the chain got SHORTER rather than broken, and every request went out
-// unauthenticated while the gate had nothing to refuse. That is fail-open
-// by omission, and it survived every other case in this file because each
-// of them configures the chain correctly.
-//
-// Both wire paths - the entity pipeline and Direct - each with a CONTROL
-// leg through the SAME live transport, so a zero means REFUSED and not
-// UNWIRED. The refusal is matched on sekreto's OWN message, so an
-// unrelated failure cannot stand in for it.
 func TestSecretsMalformedProviderEntry(t *testing.T) {
 	// A kind NAME where a provider or spec belongs.
 	malformed := []any{"hashicorp"}
@@ -1093,19 +1001,11 @@ func TestSecretsGateRecovery(t *testing.T) {
 		}},
 	})
 
-	// 1. The failure closes the gate: nothing reaches the wire.
-	//
-	// The operation is known to be routable, so an empty wire PROVES the gate
-	// refused it. Driving an arbitrary entity would pass here for the wrong
-	// reason: an operation the model never declared reaches no transport
-	// whether the gate is open or shut.
 	driveNamedOp(t, client, entity, opname)
 	if 0 != len(w.api()) {
 		t.Fatalf("a failed resolution must keep the wire silent, saw %d calls", len(w.api()))
 	}
 
-	// 2. Recovery under concurrency: two operations race the slow retry;
-	// both must come out carrying the fresh credential.
 	mu.Lock()
 	mode = "slow"
 	mu.Unlock()

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

@@ -1,19 +1,5 @@
 package sdktest
 
-// Feature behaviour, driven by the SHARED corpus.
-//
-// The same route primary_utility_test.go takes for the utilities:
-// language-neutral cases in .sdk/test/test.json, executed against THIS
-// generated SDK. The feature is the ordinary compiled type, built by the
-// generated config, installed by the generated constructor, and driven by a
-// real entity operation. Not a miniature of the pipeline - that is what
-// feature_harness_test.go does, and a miniature can only be as right as the
-// miniature.
-//
-// Everything in a case is data. The two pieces go writes for itself are
-// turning scripted responses into a FetcherFunc, and reading the record back
-// off the feature (go keeps the aggregates on the feature value, where ts
-// keeps them on the client).
 
 import (
 	"encoding/json"
@@ -32,17 +18,13 @@ import (
 // added under .sdk/test/feature/ — runs without editing this file. An
 // SDK generated without a listed feature still skips, not fails.
 
-// The standard operation names, in the order the runner prefers them. Every
-// entity declares every CRUD method, so an op that the API does not define
-// errors at runtime rather than failing to compile - which is why usable
-// operations are found by DRIVING them, below.
 var featureCorpusOps = []string{"Load", "List", "Create", "Update", "Remove"}
 
 // One operation this SDK can actually perform.
 type fcOp struct {
 	key      string // "<entity>.<op>", how features attribute it
 	accessor string // the client method returning the entity
-	method   string // the op method on that entity
+	method   string
 }
 
 // fcFetcher builds a scripted transport from a case's `res` list. Responses
@@ -106,20 +88,8 @@ func fcFetcher(res []any) sdk.FetcherFunc {
 	}
 }
 
-// fcClient builds a client the way a caller would: the generated constructor,
-// the feature list from the case, and the scripted transport through the
-// documented `utility.fetcher` override.
-//
-// NewProjectNameSDK, not TestSDK: the `test` feature is transport: 'base' and
-// REPLACES the transport, so a client in test mode would shadow the script.
 func fcClient(kase map[string]any) *sdk.ProjectNameSDK {
 	res, _ := kase["res"].([]any)
-	// "test" here is the OPTION, not the `test` FEATURE. It says "this
-	// client is not live", which is what makes a REQUIRED OpenAPI server
-	// variable resolve to a deterministic test-<name> rather than panic at
-	// construction (see makeOptions). It installs no transport, so the
-	// scripted fetcher still stands — the FEATURE is transport: 'base' and
-	// would shadow it, which is why this cannot just turn the feature on.
 	opts := map[string]any{
 		"test":    map[string]any{"active": true},
 		"utility": map[string]any{"fetcher": fcFetcher(res)},
@@ -338,13 +308,6 @@ func fcNum(v any) (float64, bool) {
 	return 0, false
 }
 
-// fcSubset asserts that `actual` contains `expect`, recursively. Cases assert
-// only the fields they are about, so a full deep-equal would force every case
-// to restate the whole record.
-//
-// `actual` is a Go value, not a map: the aggregates live on the feature as
-// typed structs, so an expected key is matched to an exported field by
-// capitalising it.
 func fcSubset(t *testing.T, actual any, expect any, path string) {
 	t.Helper()
 
@@ -410,21 +373,6 @@ func fcMember(actual any, key string) (any, bool) {
 	return nil, false
 }
 
-// fcRecord finds the named feature on the client and hands back the value
-// carrying its aggregates. go keeps them on the feature; ts keeps them on the
-// client. Same data, different home.
-//
-// Returned as the feature value itself, NOT type-asserted to a concrete
-// feature type. Naming one here would be a compile-time reference to a
-// feature the project may not have: `target add` trims unselected features,
-// and this template is not trimmed with them, so an SDK generated without
-// that feature would ship a test that does not build. featuresource.test.ts
-// guards exactly that, and caught it - including, on its first pass, the
-// spelling of the type inside this very comment.
-//
-// fcSubset reads the expected keys off the struct by capitalising them, so
-// `total` finds Total, `ops` finds Ops, and a feature added later needs no
-// new go here.
 func fcRecord(client *sdk.ProjectNameSDK, name string) any {
 	for _, f := range client.Features {
 		if f.GetName() == name {
@@ -439,13 +387,6 @@ func TestFeatureCorpus(t *testing.T) {
 
 	featureSection := getSpec(spec, "feature")
 	if featureSection == nil {
-		// A corpus with no `feature` section is a SKIP, not a failure. Each
-		// project carries its OWN materialised copy of .sdk/test/test.json, so a
-		// project scaffolded before the section existed legitimately has no cases
-		// to run - and a hard assertion here turned that into a red suite in every
-		// SDK on the fleet, for a corpus the project had simply not re-pulled yet.
-		// The strict check belongs where the corpus is CONTROLLED: sdkgen's own
-		// end-to-end lane supplies one and requires the cases to actually run.
 		t.Skip("this project's test.json has no `feature` section - recompile the corpus (create-sdkgen .sdk/test/feature/) to run these cases")
 	}
 

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

@@ -1,15 +1,5 @@
 package sdktest
 
-// Offline feature-test harness: a faithful miniature of the real operation
-// pipeline (same hook order and short-circuit rules as the generated
-// Entity*Op code) driven against a configurable mock transport, with no
-// live server and no API-specific fixtures.
-//
-// SEPARATE FROM feature_test.go ON PURPOSE. `target add` drops the
-// cross-feature suite when a project trims its feature set (it constructs
-// every shipped feature by name), but pipeline_test.go and friends use
-// these fh* helpers too — leaving them in feature_test.go took the whole
-// test package down with it.
 
 import (
 	"fmt"

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/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)