@voxgig/sdkgen 4.5.3 → 4.7.0

package/project/.sdk/tm/dart/test/utility.dart

@@ -143,6 +143,45 @@ bool skipIfMissingIds(T t, Map setup, List<String> requiredKeys) {
 
 // Per-test live pacing delay (ms). Read from sdk-test-control.json
 // `test.live.delayMs`; defaults to 500ms if absent or invalid.
+// Extra SDK options every LIVE client is constructed with, read 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.
+//
+// Reserved fields are stripped HERE rather than at 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.
+const List<String> liveReserved = [
+  'base', 'prefix', 'suffix', 'server', 'apikey', 'secret'
+];
+
+Map<String, dynamic> liveClientOptions() {
+  final ctrl = loadTestControl();
+  final t = ctrl['test'];
+  if (t is! Map) return <String, dynamic>{};
+  final c = t['client'];
+  if (c is! Map) return <String, dynamic>{};
+  final opts = c['options'];
+  if (opts is! Map) return <String, dynamic>{};
+
+  final out = <String, dynamic>{};
+  opts.forEach((k, v) {
+    if (!liveReserved.contains(k)) {
+      out['$k'] = v;
+    }
+  });
+  return out;
+}
+
+
 int liveDelayMs() {
   final ctrl = loadTestControl();
   final t = ctrl['test'];

package/project/.sdk/tm/elixir/lib/projectname/utility.ex

@@ -243,8 +243,24 @@ defmodule ProjectName.Utility do
       end
     end
 
+    # `auth` nil is the documented way to disable auth outright, and
+    # prepare_auth honours it before it ever reads the apikey. It cannot
+    # survive validate: a stored null reads as "no value", so the optspec's
+    # `auth` default fires and the suppression silently becomes "use default
+    # auth" - transmitting the credential the caller withheld. Withhold the
+    # key for validate, then put the nil back. Same fix as ts/js/go
+    # makeOptions.
+    #
+    # keysof rather than S.haskey: haskey is `getprop(...) != nil`, which
+    # collapses a stored null and so cannot tell an ABSENT auth from a
+    # suppressed one. keysof lists the key either way.
+    auth_suppressed =
+      S.ismap(options) and "auth" in S.keysof(options) and
+        S.getprop(options, "auth") == nil
+
     opts0 = S.clone(options)
     opts0 = if S.ismap(opts0), do: opts0, else: S.jm([])
+    if auth_suppressed, do: S.delprop(opts0, "auth")
 
     # Feature add-order. options.feature may be given as an ordered LIST of
     # {name, active, ...opts} entries (list position = add order) or a
@@ -329,6 +345,9 @@ defmodule ProjectName.Utility do
     validated = S.validate(merged, optspec)
     opts = if S.ismap(validated), do: validated, else: S.jm([])
 
+    # Restore the suppression the optspec default would otherwise erase.
+    if auth_suppressed, do: S.setprop(opts, "auth", nil)
+
     # Resolve a templated base URL (e.g. https://{tenant_id}.hanko.io).
     # Every placeholder must resolve to a non-empty value: from options.server
     # (user), else the Config default. A placeholder that resolves to "" is a

package/project/.sdk/tm/go/core/context.go

@@ -245,7 +245,7 @@ func (ctx *Context) resolveOp(opname string) *Operation {
 		return NewOperation(map[string]any{})
 	}
 
-	opcfg := vs.GetPath([]any{"entity", entname, "op", opname}, ctx.Config)
+	opcfg := vs.GetPath(ctx.Config, []any{"entity", entname, "op", opname})
 
 	input := "match"
 	if opname == "update" || opname == "create" {

package/project/.sdk/tm/go/feature/cost_feature.go

@@ -367,7 +367,7 @@ func (f *CostFeature) body(ctx *core.Context) (float64, bool) {
 		return 0, false
 	}
 
-	switch n := vs.GetPath(path, ctx.Result.Body).(type) {
+	switch n := vs.GetPath(ctx.Result.Body, path).(type) {
 	case int:
 		return float64(n) * f.perUnit(), true
 	case int64:

package/project/.sdk/tm/go/feature/paging_feature.go

@@ -109,7 +109,7 @@ func (f *PagingFeature) graphqlPreRequest(ctx *core.Context, paging map[string]a
 	// Only bind variables the operation actually declares, or the server
 	// rejects the document.
 	declared := map[string]bool{}
-	if varlist, ok := vs.GetPath([]any{"graphql", "vars"}, ctx.Point).([]any); ok {
+	if varlist, ok := vs.GetPath(ctx.Point, []any{"graphql", "vars"}).([]any); ok {
 		for _, v := range varlist {
 			if name, ok := vs.GetProp(v, "name").(string); ok {
 				declared[name] = true
@@ -160,7 +160,7 @@ func (f *PagingFeature) PreResult(ctx *core.Context) {
 
 	// Relay connections carry the cursor in pageInfo, at the path the model
 	// recorded for this op.
-	page := vs.GetPath([]any{"graphql", "page"}, ctx.Point)
+	page := vs.GetPath(ctx.Point, []any{"graphql", "page"})
 	if pm, ok := page.(map[string]any); ok {
 		if _, isMap := body.(map[string]any); isMap {
 			// `connpath` locates the connection object inside the response
@@ -168,18 +168,18 @@ func (f *PagingFeature) PreResult(ctx *core.Context) {
 			// to it.
 			conn := body
 			if cp, ok := pm["connpath"].(string); ok && cp != "" {
-				if sub := vs.GetPath(cp, body); sub != nil {
+				if sub := vs.GetPath(body, cp); sub != nil {
 					conn = sub
 				}
 			}
 
 			if cp, ok := pm["cursor"].(string); ok && cp != "" {
-				if cursor := vs.GetPath(cp, conn); cursor != nil {
+				if cursor := vs.GetPath(conn, cp); cursor != nil {
 					paging["cursor"] = cursor
 				}
 			}
 			if mp, ok := pm["more"].(string); ok && mp != "" {
-				if more, ok := vs.GetPath(mp, conn).(bool); ok {
+				if more, ok := vs.GetPath(conn, mp).(bool); ok {
 					paging["hasMore"] = more
 					explicitMore = true
 				}

package/project/.sdk/tm/go/feature/test_feature.go

@@ -323,7 +323,7 @@ func (f *TestFeature) buildArgs(ctx *core.Context, op *core.Operation, args map[
 	// back to, so the seed-data query is built from the endpoint the request
 	// will actually be sent to: a terminal `{id}` marks a record route, and
 	// failing that the shallower path wins.
-	points := vs.GetPath([]any{"entity", ctx.Entity.GetName(), "op", opname, "points"}, ctx.Config)
+	points := vs.GetPath(ctx.Config, []any{"entity", ctx.Entity.GetName(), "op", opname, "points"})
 	point := vs.GetElem(points, 0)
 	if plist, ok := points.([]any); ok {
 		partsLen := func(p any) int {
@@ -355,12 +355,19 @@ func (f *TestFeature) buildArgs(ctx *core.Context, op *core.Operation, args map[
 
 	// Path AND query: a path-only read misses a query-addressed record
 	// (e.g. GET /result?trace_id=), which has no path param at all.
-	paramsPath := vs.GetPath([]any{"args", "params"}, point)
+	paramsPath := vs.GetPath(point, []any{"args", "params"})
 	reqdParams := vs.Select(paramsPath, map[string]any{"reqd": true})
-	reqdFromParams := vs.Transform(reqdParams, []any{"`$EACH`", "", "`$KEY.name`"})
-	queryPath := vs.GetPath([]any{"args", "query"}, point)
+	// The error return Transform gained in struct go 0.1.3 is discarded
+	// DELIBERATELY here, unlike in transform_request/response: these two
+	// transform a spec the SDK itself built from the point definition, not
+	// user data, so an error means a generator bug rather than something a
+	// caller can act on — and buildArgs has no error seam to route it
+	// through. An empty result is the conservative outcome: no required
+	// fields, which is what an absent spec already produces.
+	reqdFromParams, _ := vs.Transform(reqdParams, []any{"`$EACH`", "", "`$KEY.name`"})
+	queryPath := vs.GetPath(point, []any{"args", "query"})
 	reqdQuery := vs.Select(queryPath, map[string]any{"reqd": true})
-	reqdFromQuery := vs.Transform(reqdQuery, []any{"`$EACH`", "", "`$KEY.name`"})
+	reqdFromQuery, _ := vs.Transform(reqdQuery, []any{"`$EACH`", "", "`$KEY.name`"})
 
 	qand := []any{}
 	q := map[string]any{"`$AND`": &qand}

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

@@ -109,7 +109,12 @@ func TestCustomUtility(t *testing.T) {
 		// that was broken: a plain function literal in a map[string]any has the
 		// unnamed signature, so an override that only accepted the named type
 		// shelved it in Custom. Converting here would have hidden that.
+		// "test" is the OPTION, not the `test` FEATURE: it says "this client
+		// is not live", so a REQUIRED OpenAPI server variable resolves to a
+		// deterministic test-<name> instead of panicking at construction. It
+		// installs no transport, so the override under test still stands.
 		client := sdk.NewProjectNameSDK(map[string]any{
+			"test":    map[string]any{"active": true},
 			"utility": map[string]any{"fetcher": scripted},
 		})
 
@@ -138,7 +143,12 @@ func TestCustomUtility(t *testing.T) {
 	// the subtest above, and broken by any fix that swaps one for the other.
 	t.Run("a converted fetcher is accepted too", func(t *testing.T) {
 		reached := 0
+		// "test" is the OPTION, not the `test` FEATURE: it says "this client
+		// is not live", so a REQUIRED OpenAPI server variable resolves to a
+		// deterministic test-<name> instead of panicking at construction. It
+		// installs no transport, so the override under test still stands.
 		client := sdk.NewProjectNameSDK(map[string]any{
+			"test": map[string]any{"active": true},
 			"utility": map[string]any{
 				"fetcher": sdk.FetcherFunc(func(
 					ctx *sdk.Context, fullurl string, fetchdef map[string]any,
@@ -171,7 +181,12 @@ func TestCustomUtility(t *testing.T) {
 	// An unknown key must still be attached rather than dropped, so the two
 	// halves cannot be satisfied by a switch that also swallows extras.
 	t.Run("an unknown key is still attached", func(t *testing.T) {
+		// "test" is the OPTION, not the `test` FEATURE: it says "this client
+		// is not live", so a REQUIRED OpenAPI server variable resolves to a
+		// deterministic test-<name> instead of panicking at construction. It
+		// installs no transport, so the override under test still stands.
 		client := sdk.NewProjectNameSDK(map[string]any{
+			"test": map[string]any{"active": true},
 			"utility": map[string]any{
 				"notAUtilityMember": func() string { return "EXTRA" },
 			},

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

@@ -114,7 +114,14 @@ func fcFetcher(res []any) sdk.FetcherFunc {
 // 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)},
 	}
 	if f, ok := kase["feature"]; ok {

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

@@ -156,6 +156,52 @@ func isControlSkipped(kind, name, mode string) (bool, string) {
 }
 
 // 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,
+}
+
+func liveClientOptions() map[string]any {
+	ctrl := loadTestControl()
+	test, _ := ctrl["test"].(map[string]any)
+	if test == nil {
+		return map[string]any{}
+	}
+	client, _ := test["client"].(map[string]any)
+	if client == nil {
+		return map[string]any{}
+	}
+	opts, _ := client["options"].(map[string]any)
+	if opts == nil {
+		return map[string]any{}
+	}
+
+	out := map[string]any{}
+	for k, v := range opts {
+		if !liveReserved[k] {
+			out[k] = v
+		}
+	}
+	return out
+}
+
+
 func liveDelayMs() int {
 	ctrl := loadTestControl()
 	test, _ := ctrl["test"].(map[string]any)

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

@@ -33,7 +33,7 @@ type StructUtility struct {
 	IsNode     func(val any) bool
 	Clone      func(val any) any
 	CloneFlags func(val any, flags map[string]bool) any
-	GetPath    func(path any, store any, injdefs ...*voxgigstruct.Injection) any
+	GetPath    func(store any, path any, injdefs ...*voxgigstruct.Injection) any
 	Inject     func(val any, store any, injdefs ...*voxgigstruct.Injection) any
 	Items      func(val any) [][2]any
 	Stringify  func(val any, maxlen ...int) string
@@ -65,7 +65,7 @@ type StructUtility struct {
 	Size       func(val any) int
 	Slice      func(val any, args ...any) any
 	StrKey     func(key any) string
-	Transform  func(data any, spec any, injdefs ...*voxgigstruct.Injection) any
+	Transform  func(data any, spec any, injdefs ...*voxgigstruct.Injection) (any, error)
 	Typify     func(value any) int
 	Typename   func(t int) string
 	Validate   func(data any, spec any, injdefs ...*voxgigstruct.Injection) (any, error)
@@ -73,8 +73,8 @@ type StructUtility struct {
 	SKIP   any
 	DELETE any
 
-	Jo func(kv ...any) map[string]any
-	Ja func(v ...any) []any
+	Jm func(kv ...any) map[string]any
+	Jt func(v ...any) []any
 
 	CheckPlacement func(modes int, ijname string, parentTypes int, inj *voxgigstruct.Injection) bool
 	InjectorArgs   func(argTypes []int, args []any) []any
@@ -681,7 +681,7 @@ func MatchNode(
 			scalar := !structUtil.IsNode(val)
 
 			if scalar {
-				baseval := structUtil.GetPath(path, base)
+				baseval := structUtil.GetPath(base, path)
 				if !MatchScalar(val, baseval, structUtil) {
 					pass = false
 					err = fmt.Errorf(
@@ -1058,8 +1058,8 @@ func NewStructSDK(opts map[string]any) *StructSDK {
 		SKIP:   voxgigstruct.SKIP,
 		DELETE: voxgigstruct.DELETE,
 
-		Jo: voxgigstruct.Jo,
-		Ja: voxgigstruct.Ja,
+		Jm: voxgigstruct.Jm,
+		Jt: voxgigstruct.Jt,
 
 		CheckPlacement: voxgigstruct.CheckPlacement,
 		InjectorArgs:   voxgigstruct.InjectorArgs,

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

@@ -159,20 +159,44 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("minor-escurl", func(t *testing.T) {
-		structRunSet(t, minorSpec["escurl"], func(in string) string {
-			return strings.ReplaceAll(voxgigstruct.EscUrl(fmt.Sprint(in)), "+", "%20")
-		})
+		// 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)
 	})
 
 	t.Run("minor-stringify", func(t *testing.T) {
 		structRunSet(t, minorSpec["stringify"], func(v any) any {
 			m := v.(map[string]any)
-			val := m["val"]
+			val, hasVal := m["val"]
 
 			if "__NULL__" == val {
 				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 ""
+			}
+
 			max, hasMax := m["max"]
 			if !hasMax || nil == max {
 				return voxgigstruct.Stringify(val)
@@ -585,9 +609,21 @@ func TestStructUtility(t *testing.T) {
 			} else {
 				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)
+			}
+
 			entry := "k=" + voxgigstruct.Stringify(ks) +
 				", v=" + voxgigstruct.Stringify(v) +
-				", p=" + voxgigstruct.Stringify(p) +
+				", p=" + ps +
 				", t=" + voxgigstruct.Pathify(t)
 			return entry
 		}
@@ -840,7 +876,7 @@ func TestStructUtility(t *testing.T) {
 			path := m["path"]
 			store := m["store"]
 
-			return voxgigstruct.GetPath(path, store)
+			return voxgigstruct.GetPath(store, path)
 		})
 	})
 
@@ -862,7 +898,7 @@ func TestStructUtility(t *testing.T) {
 				Dpath:   dpath,
 			}
 
-			return voxgigstruct.GetPath(path, store, inj)
+			return voxgigstruct.GetPath(store, path, inj)
 		})
 	})
 
@@ -884,10 +920,10 @@ func TestStructUtility(t *testing.T) {
 						inj.Meta = metaMap
 					}
 				}
-				return voxgigstruct.GetPath(path, store, inj)
+				return voxgigstruct.GetPath(store, path, inj)
 			}
 
-			return voxgigstruct.GetPath(path, store)
+			return voxgigstruct.GetPath(store, path)
 		})
 	})
 
@@ -947,14 +983,14 @@ func TestStructUtility(t *testing.T) {
 		data := inVal["data"]
 		spec := inVal["spec"]
 		outVal := subtest["out"]
-		result := voxgigstruct.Transform(data, spec)
+		result, _ := voxgigstruct.Transform(data, spec)
 		if !reflect.DeepEqual(result, outVal) {
 			t.Errorf("Expected: %v, Got: %v", outVal, result)
 		}
 	})
 
 	t.Run("transform-paths", func(t *testing.T) {
-		structRunSet(t, transformSpec["paths"], func(v any) any {
+		structRunSet(t, transformSpec["paths"], func(v any) (any, error) {
 			m := v.(map[string]any)
 			data := m["data"]
 			spec := m["spec"]
@@ -963,7 +999,7 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("transform-cmds", func(t *testing.T) {
-		structRunSet(t, transformSpec["cmds"], func(v any) any {
+		structRunSet(t, transformSpec["cmds"], func(v any) (any, error) {
 			m := v.(map[string]any)
 			data := m["data"]
 			spec := m["spec"]
@@ -972,7 +1008,7 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("transform-each", func(t *testing.T) {
-		structRunSet(t, transformSpec["each"], func(v any) any {
+		structRunSet(t, transformSpec["each"], func(v any) (any, error) {
 			m := v.(map[string]any)
 			data := m["data"]
 			spec := m["spec"]
@@ -981,7 +1017,7 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("transform-pack", func(t *testing.T) {
-		structRunSet(t, transformSpec["pack"], func(v any) any {
+		structRunSet(t, transformSpec["pack"], func(v any) (any, error) {
 			m := v.(map[string]any)
 			data := m["data"]
 			spec := m["spec"]
@@ -990,7 +1026,7 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("transform-ref", func(t *testing.T) {
-		structRunSet(t, transformSpec["ref"], func(v any) any {
+		structRunSet(t, transformSpec["ref"], func(v any) (any, error) {
 			m := v.(map[string]any)
 			data := m["data"]
 			spec := m["spec"]
@@ -999,7 +1035,7 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("transform-format", func(t *testing.T) {
-		structRunSetFlags(t, transformSpec["format"], map[string]bool{"null": false}, func(v any) any {
+		structRunSetFlags(t, transformSpec["format"], map[string]bool{"null": false}, func(v any) (any, error) {
 			m := v.(map[string]any)
 			data := m["data"]
 			spec := m["spec"]
@@ -1021,7 +1057,7 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("transform-edge-apply", func(t *testing.T) {
-		result := voxgigstruct.Transform(
+		result, _ := voxgigstruct.Transform(
 			map[string]any{},
 			[]any{"`$APPLY`", func(v any) any { return 1 + v.(int) }, 1},
 		)
@@ -1105,25 +1141,25 @@ func TestStructUtility(t *testing.T) {
 	t.Run("transform-funcval", func(t *testing.T) {
 		f0 := func() int { return 22 }
 
-		result1 := voxgigstruct.Transform(map[string]any{}, map[string]any{"x": 1})
+		result1, _ := voxgigstruct.Transform(map[string]any{}, map[string]any{"x": 1})
 		expected1 := map[string]any{"x": 1}
 		if !reflect.DeepEqual(expected1, result1) {
 			t.Errorf("Expected simple value transform result")
 		}
 
-		result2 := voxgigstruct.Transform(map[string]any{}, map[string]any{"x": f0})
+		result2, _ := voxgigstruct.Transform(map[string]any{}, map[string]any{"x": f0})
 		var fr0 = result2.(map[string]any)["x"].(func() int)
 		if f0() != fr0() {
 			t.Errorf("Expected x to be f0")
 		}
 
-		result3 := voxgigstruct.Transform(map[string]any{"a": 1}, map[string]any{"x": "`a`"})
+		result3, _ := voxgigstruct.Transform(map[string]any{"a": 1}, map[string]any{"x": "`a`"})
 		expected3 := map[string]any{"x": 1}
 		if !reflect.DeepEqual(expected3, result3) {
 			t.Errorf("Expected value lookup transform to work")
 		}
 
-		result4 := voxgigstruct.Transform(map[string]any{"f0": f0}, map[string]any{"x": "`f0`"})
+		result4, _ := voxgigstruct.Transform(map[string]any{"f0": f0}, map[string]any{"x": "`f0`"})
 		var fr4 = result4.(map[string]any)["x"].(func() int)
 		if 22 != fr4() {
 			t.Errorf("Expected function to be preserved")
@@ -1347,22 +1383,22 @@ func TestStructUtility(t *testing.T) {
 
 	t.Run("json-builder", func(t *testing.T) {
 		expected0 := "{\n  \"a\": 1\n}"
-		result0 := voxgigstruct.Jsonify(voxgigstruct.Jo("a", 1))
+		result0 := voxgigstruct.Jsonify(voxgigstruct.Jm("a", 1))
 		if result0 != expected0 {
 			t.Errorf("Expected: %v, Got: %v", expected0, result0)
 		}
 
 		expected1 := "[\n  \"b\",\n  2\n]"
-		result1 := voxgigstruct.Jsonify(voxgigstruct.Ja("b", 2))
+		result1 := voxgigstruct.Jsonify(voxgigstruct.Jt("b", 2))
 		if result1 != expected1 {
 			t.Errorf("Expected: %v, Got: %v", expected1, result1)
 		}
 
 		expected2 := "{\n  \"c\": \"C\",\n  \"d\": {\n    \"x\": true\n  },\n  \"e\": [\n    null,\n    false\n  ]\n}"
-		result2 := voxgigstruct.Jsonify(voxgigstruct.Jo(
+		result2 := voxgigstruct.Jsonify(voxgigstruct.Jm(
 			"c", "C",
-			"d", voxgigstruct.Jo("x", true),
-			"e", voxgigstruct.Ja(nil, false),
+			"d", voxgigstruct.Jm("x", true),
+			"e", voxgigstruct.Jt(nil, false),
 		))
 		if result2 != expected2 {
 			t.Errorf("Expected:\n%v\nGot:\n%v", expected2, result2)
@@ -1397,7 +1433,7 @@ func TestStructUtility(t *testing.T) {
 				},
 			}
 
-			return voxgigstruct.GetPath(path, store, inj)
+			return voxgigstruct.GetPath(store, path, inj)
 		})
 	})
 }

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

@@ -118,13 +118,13 @@ func fetcherUtil(ctx *core.Context, fullurl string, fetchdef map[string]any) (an
 	}
 
 	options := ctx.Client.OptionsMap()
-	if vs.GetPath([]any{"feature", "test", "active"}, options) == true {
+	if vs.GetPath(options, []any{"feature", "test", "active"}) == true {
 		return nil, ctx.MakeError("fetch_test_block",
 			"Request blocked as test feature is active"+
 				" (URL was: \""+fullurl+"\")")
 	}
 
-	sysFetch := vs.GetPath([]any{"system", "fetch"}, options)
+	sysFetch := vs.GetPath(options, []any{"system", "fetch"})
 
 	if sysFetch == nil {
 		return defaultHTTPFetch(fullurl, fetchdef)

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

@@ -36,6 +36,20 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 		}
 	}
 
+	// `auth: nil` is the documented way to disable auth outright, and
+	// prepareAuth honours it before it ever reads the apikey. But validate
+	// treats a stored nil as "no value", so the optspec's `auth` default
+	// fires and the suppression silently becomes "use default auth" —
+	// transmitting a credential the caller explicitly asked not to send.
+	//
+	// Suppliedness cannot be recovered after validate, hence here. The
+	// two-value form is required: options["auth"] reads nil both when the
+	// key is ABSENT and when it is present and nil, and only the second is
+	// a suppression. (ts gets this for free — `null === options.auth` is
+	// false for an omitted key, since that reads undefined.)
+	authval, authgiven := options["auth"]
+	authsuppressed := authgiven && authval == nil
+
 	opts := vs.Clone(options).(map[string]any)
 
 	// Feature add-order (feature #2). options.feature may be given as an ordered
@@ -129,7 +143,7 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 
 	// Preserve system.fetch before merge/validate.
 	var sysFetch any
-	if sf := vs.GetPath([]any{"system", "fetch"}, opts); sf != nil {
+	if sf := vs.GetPath(opts, []any{"system", "fetch"}); sf != nil {
 		sysFetch = sf
 	}
 
@@ -141,6 +155,11 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 	validated, _ := vs.Validate(merged, optspec)
 	opts = validated.(map[string]any)
 
+	// Restore the suppression the optspec default would otherwise erase.
+	if authsuppressed {
+		opts["auth"] = nil
+	}
+
 	// Resolve a templated base URL (e.g. https://{tenant_id}.hanko.io).
 	// Every placeholder must resolve to a non-empty value: from
 	// options["server"] (user), else the config default. A placeholder that
@@ -151,15 +170,15 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 	// PANICS (construction-time misconfiguration, as regexp.MustCompile).
 	if base, ok := opts["base"].(string); ok && strings.Contains(base, "{") {
 		testmode := false
-		if ta, ok := vs.GetPath([]any{"test", "active"}, opts).(bool); ok && ta {
+		if ta, ok := vs.GetPath(opts, []any{"test", "active"}).(bool); ok && ta {
 			testmode = true
 		}
-		if fa, ok := vs.GetPath([]any{"feature", "test", "active"}, opts).(bool); ok && fa {
+		if fa, ok := vs.GetPath(opts, []any{"feature", "test", "active"}).(bool); ok && fa {
 			testmode = true
 		}
 		server := core.ToMapAny(opts["server"])
 		sdkname := "SDK"
-		if mn, ok := vs.GetPath([]any{"main", "name"}, config).(string); ok && mn != "" {
+		if mn, ok := vs.GetPath(config, []any{"main", "name"}).(string); ok && mn != "" {
 			sdkname = mn
 		}
 		resolved := serverVarRe.ReplaceAllStringFunc(base, func(ph string) string {
@@ -191,7 +210,7 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 
 	// Derived clean config.
 	cleanKeys := "key,token,id"
-	if ck := vs.GetPath([]any{"clean", "keys"}, opts); ck != nil {
+	if ck := vs.GetPath(opts, []any{"clean", "keys"}); ck != nil {
 		if cks, ok := ck.(string); ok {
 			cleanKeys = cks
 		}