@voxgig/sdkgen 1.3.17 → 1.3.19

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

@@ -1,6 +1,7 @@
 package sdktest
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
@@ -119,7 +120,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("done-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "done", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "done", getSpec(primary, "done", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			fixctx(ctx, client)
@@ -128,7 +129,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeError-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "makeError", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "makeError", getSpec(primary, "makeError", "basic"), func(entry map[string]any) (any, error) {
 			args, _ := entry["args"].([]any)
 			if len(args) == 0 {
 				args = []any{map[string]any{}}
@@ -251,6 +252,10 @@ 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) {
 					calls = append(calls, map[string]any{"url": url, "init": fetchdef})
@@ -281,6 +286,7 @@ func TestPrimaryUtility(t *testing.T) {
 	t.Run("fetcher-blocked-test-mode", func(t *testing.T) {
 		// Create a live SDK then set mode to test (not using TestSDK, which installs test feature)
 		blockedClient := sdk.NewProjectNameSDK(map[string]any{
+			"base": "http://localhost:8080",
 			"system": map[string]any{
 				"fetch": func(url string, fetchdef map[string]any) (map[string]any, error) {
 					return map[string]any{}, nil
@@ -306,7 +312,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeContext-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "makeContext", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "makeContext", getSpec(primary, "makeContext", "basic"), func(entry map[string]any) (any, error) {
 			in := entry["in"]
 			if inMap, ok := in.(map[string]any); ok {
 				ctx := utility.MakeContext(inMap, nil)
@@ -395,7 +401,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeOptions-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "makeOptions", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "makeOptions", getSpec(primary, "makeOptions", "basic"), func(entry map[string]any) (any, error) {
 			in, _ := entry["in"].(map[string]any)
 			ctx := utility.MakeContext(map[string]any{
 				"options": in["options"],
@@ -408,7 +414,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeRequest-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "makeRequest", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "makeRequest", getSpec(primary, "makeRequest", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			ctx.Options = client.OptionsMap()
@@ -432,7 +438,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeResponse-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "makeResponse", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "makeResponse", getSpec(primary, "makeResponse", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			fixctx(ctx, client)
@@ -521,7 +527,7 @@ func TestPrimaryUtility(t *testing.T) {
 		specClient := sdk.TestSDK(nil, setupOpts)
 		specUtility := specClient.GetUtility()
 
-		runset(t, getSpec(primary, "makeSpec", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "makeSpec", getSpec(primary, "makeSpec", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, specClient, specUtility)
 			ctx.Options = specClient.OptionsMap()
@@ -574,7 +580,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("makeUrl-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "makeUrl", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "makeUrl", getSpec(primary, "makeUrl", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			if ctx.Result == nil {
@@ -585,7 +591,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("operator-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "operator", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "operator", getSpec(primary, "operator", "basic"), func(entry map[string]any) (any, error) {
 			in, _ := entry["in"].(map[string]any)
 			op := sdk.NewOperation(in)
 			return map[string]any{
@@ -598,7 +604,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("param-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "param", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "param", getSpec(primary, "param", "basic"), func(entry map[string]any) (any, error) {
 			args, _ := entry["args"].([]any)
 			if len(args) < 2 {
 				return nil, nil
@@ -647,7 +653,7 @@ func TestPrimaryUtility(t *testing.T) {
 		authClient := sdk.TestSDK(nil, setupOpts)
 		authUtility := authClient.GetUtility()
 
-		runset(t, getSpec(primary, "prepareAuth", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "prepareAuth", getSpec(primary, "prepareAuth", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, authClient, authUtility)
 			fixctx(ctx, authClient)
@@ -670,7 +676,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("prepareBody-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "prepareBody", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "prepareBody", getSpec(primary, "prepareBody", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			fixctx(ctx, client)
@@ -679,7 +685,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("prepareHeaders-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "prepareHeaders", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "prepareHeaders", getSpec(primary, "prepareHeaders", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			return utility.PrepareHeaders(ctx), nil
@@ -687,7 +693,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("prepareMethod-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "prepareMethod", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "prepareMethod", getSpec(primary, "prepareMethod", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			return utility.PrepareMethod(ctx), nil
@@ -695,41 +701,39 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("prepareParams-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "prepareParams", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "prepareParams", getSpec(primary, "prepareParams", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			return utility.PrepareParams(ctx), nil
 		})
 	})
 
+	// 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) {
-		ctx := makeTestFullCtx(client, utility)
-		ctx.Point = map[string]any{
-			"parts": []any{"api", "planet", "{id}"},
-			"args":  map[string]any{"params": []any{}},
-		}
-
-		path := utility.PreparePath(ctx)
-		if path != "api/planet/{id}" {
-			t.Errorf("expected api/planet/{id}, got %s", path)
-		}
+		runsetNamed(t, "preparePath", getSpec(primary, "preparePath", "basic"), func(entry map[string]any) (any, error) {
+			ctxmap, _ := entry["ctx"].(map[string]any)
+			ctx := makeCtxFromMap(ctxmap, client, utility)
+			return utility.PreparePath(ctx), nil
+		})
 	})
 
-	t.Run("preparePath-single", func(t *testing.T) {
-		ctx := makeTestFullCtx(client, utility)
-		ctx.Point = map[string]any{
-			"parts": []any{"items"},
-			"args":  map[string]any{"params": []any{}},
-		}
-
-		path := utility.PreparePath(ctx)
-		if path != "items" {
-			t.Errorf("expected items, got %s", path)
-		}
+	t.Run("clean-corpus", func(t *testing.T) {
+		runsetNamed(t, "clean", getSpec(primary, "clean", "basic"), func(entry map[string]any) (any, error) {
+			args, _ := entry["args"].([]any)
+			if 2 != len(args) {
+				return nil, fmt.Errorf("clean: expected 2 args, got %d", len(args))
+			}
+			ctxmap, _ := args[0].(map[string]any)
+			ctx := makeCtxFromMap(ctxmap, client, utility)
+			return utility.Clean(ctx, args[1]), nil
+		})
 	})
 
 	t.Run("prepareQuery-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "prepareQuery", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "prepareQuery", getSpec(primary, "prepareQuery", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			return utility.PrepareQuery(ctx), nil
@@ -737,7 +741,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("resultBasic-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "resultBasic", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "resultBasic", getSpec(primary, "resultBasic", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 			fixctx(ctx, client)
@@ -759,7 +763,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("resultBody-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "resultBody", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "resultBody", getSpec(primary, "resultBody", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 
@@ -778,7 +782,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("resultHeaders-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "resultHeaders", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "resultHeaders", getSpec(primary, "resultHeaders", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 
@@ -797,7 +801,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("transformRequest-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "transformRequest", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "transformRequest", getSpec(primary, "transformRequest", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 
@@ -816,7 +820,7 @@ func TestPrimaryUtility(t *testing.T) {
 	})
 
 	t.Run("transformResponse-basic", func(t *testing.T) {
-		runset(t, getSpec(primary, "transformResponse", "basic"), func(entry map[string]any) (any, error) {
+		runsetNamed(t, "transformResponse", getSpec(primary, "transformResponse", "basic"), func(entry map[string]any) (any, error) {
 			ctxmap, _ := entry["ctx"].(map[string]any)
 			ctx := makeCtxFromMap(ctxmap, client, utility)
 

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

@@ -215,11 +215,40 @@ func getSpec(spec map[string]any, keys ...string) map[string]any {
 
 type RunSubject func(entry map[string]any) (any, error)
 
+// PENDING sections are the ones deliberately left empty in the shared corpus
+// (.sdk/test/primary/<name>.aontu). Everything else MUST contribute cases.
+var pendingSections = map[string]bool{
+	"fetcher": true, "makeFetchDef": true, "makePoint": true, "makeResult": true,
+	"featureAdd": true, "featureHook": true, "featureInit": true,
+}
+
+// runset drives one section of the shared test corpus.
+//
+// It used to `return` silently when "set" was missing or not a list, so a
+// renamed section, a fixture that failed to compile, or an empty set reported
+// PASS while running zero assertions — the whole point of a shared oracle
+// lost without a single red test. Both conditions are now fatal, except for
+// the sections explicitly marked PENDING in the corpus.
 func runset(t *testing.T, testspec map[string]any, subject RunSubject) {
 	t.Helper()
+	runsetNamed(t, "", testspec, subject)
+}
+
+func runsetNamed(t *testing.T, name string, testspec map[string]any, subject RunSubject) {
+	t.Helper()
+
+	if testspec == nil {
+		t.Fatalf("test corpus section %q missing — check the name against .sdk/test/primary/", name)
+	}
+
 	set, ok := testspec["set"].([]any)
 	if !ok {
-		return
+		t.Fatalf("test corpus section %q has no `set` list — zero cases would run", name)
+	}
+
+	if 0 == len(set) && !pendingSections[name] {
+		t.Fatalf("test corpus section %q is EMPTY — zero cases would run; "+
+			"add cases, or mark the fixture PENDING in .sdk/test/primary/", name)
 	}
 
 	for i, e := range set {

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

@@ -1,6 +1,7 @@
 package utility
 
 import (
+	"regexp"
 	"sort"
 	"strings"
 
@@ -9,6 +10,9 @@ import (
 	"GOMODULE/core"
 )
 
+// {name} placeholders in a templated server URL (OpenAPI server variables).
+var serverVarRe = regexp.MustCompile(`\{[A-Za-z0-9_]+\}`)
+
 func makeOptionsUtil(ctx *core.Context) map[string]any {
 	options := ctx.Options
 	if options == nil {
@@ -108,6 +112,13 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 		"clean": map[string]any{
 			"keys": "key,token,id",
 		},
+		// Server-variable values for a templated base URL (OpenAPI server
+		// variables): {name} placeholders in "base" are substituted from this
+		// map at construction. Spec defaults arrive via the generated config;
+		// user values override them.
+		"server": map[string]any{
+			"`$CHILD`": "",
+		},
 	}
 
 	// Preserve system.fetch before merge/validate.
@@ -120,6 +131,43 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 	validated, _ := vs.Validate(merged, optspec)
 	opts = validated.(map[string]any)
 
+	// 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 construction error in live mode — the URL cannot
+	// work — but in test mode substitutes the deterministic value
+	// "test-<name>" so offline tests need no configuration. The SDK
+	// constructor has no error return, so a missing required variable
+	// 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 {
+			testmode = true
+		}
+		if fa, ok := vs.GetPath([]any{"feature", "test", "active"}, opts).(bool); ok && fa {
+			testmode = true
+		}
+		server := core.ToMapAny(opts["server"])
+		sdkname := "SDK"
+		if mn, ok := vs.GetPath([]any{"main", "name"}, config).(string); ok && mn != "" {
+			sdkname = mn
+		}
+		resolved := serverVarRe.ReplaceAllStringFunc(base, func(ph string) string {
+			name := ph[1 : len(ph)-1]
+			val, _ := server[name].(string)
+			if val == "" {
+				if testmode {
+					return "test-" + name
+				}
+				panic(sdkname + ": the server variable '" + name + "' is required: " +
+					"the API base URL is '" + base + "' — pass " +
+					`options["server"].(map)["` + name + `"] in the SDK options`)
+			}
+			return val
+		})
+		opts["base"] = resolved
+	}
+
 	// Restore system.fetch.
 	if sysFetch != nil {
 		if sys, ok := opts["system"]; ok {

package/project/.sdk/tm/java/Makefile

@@ -12,10 +12,10 @@ clean:
 # --- Release: tag java/vX.Y.Z ----------------------------------------------
 # Maven Central publication (Sonatype Central Portal) is pending for this
 # target; publishing a version currently means pushing the java/vX.Y.Z git
-# tag. Run headless under the aql key vault, which injects the GitHub token
+# tag. Run headless under the boru key vault, which injects the GitHub token
 # so nothing lands on disk or argv:
-#   aql vault exec --for=github=<alias> -- make publish
-# aql `--dry-run` injects a filler token we detect to rehearse (no tag/push).
+#   boru vault exec --for=github=<alias> -- make publish
+# boru `--dry-run` injects a filler token we detect to rehearse (no tag/push).
 # set -e + tag-last: a failed push never leaves a tag behind.
 #
 # NOTE: publishing the git tag is deliberately NOT gated on `mvn test` (every
@@ -23,14 +23,14 @@ clean:
 # block the tag). Run `make test` separately in CI to gate quality.
 VERSION := $(shell cat VERSION)
 TAG := java/v$(VERSION)
-AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+BORU_DRY_RUN_FILLER := BORU-DRY-RUN-FILLER-NOT-A-REAL-SECRET
 publish:
 	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
 	  echo "tag $(TAG) already exists — bump VERSION first"; exit 1; fi
 	@set -e; \
 	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
-	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
-	  echo "[dry-run] aql filler token detected: would tag $(TAG); nothing pushed."; \
+	if [ "$$token" = "$(BORU_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] boru filler token detected: would tag $(TAG); nothing pushed."; \
 	  exit 0; \
 	fi; \
 	git tag -a "$(TAG)" -m "java v$(VERSION)"; \

package/project/.sdk/tm/java/test/PrimaryUtilityTest.java

@@ -717,32 +717,15 @@ public class PrimaryUtilityTest {
 
   @Test
   public void preparePathBasic() {
+    // Was two hand-written cases that had drifted out of the shared corpus
+    // (the preparePath fixture shipped as an empty `set: []`).
     ProjectNameSDK client = client();
     Utility utility = client.getUtility();
-    Context ctx = makeTestFullCtx(client, utility);
-    List<Object> parts = new ArrayList<>();
-    parts.add("api");
-    parts.add("planet");
-    parts.add("{id}");
-    ctx.point = fhMap(
-        "parts", parts,
-        "args", fhMap("params", new ArrayList<>()));
-
-    assertEquals("api/planet/{id}", utility.preparePath.apply(ctx));
-  }
-
-  @Test
-  public void preparePathSingle() {
-    ProjectNameSDK client = client();
-    Utility utility = client.getUtility();
-    Context ctx = makeTestFullCtx(client, utility);
-    List<Object> parts = new ArrayList<>();
-    parts.add("items");
-    ctx.point = fhMap(
-        "parts", parts,
-        "args", fhMap("params", new ArrayList<>()));
-
-    assertEquals("items", utility.preparePath.apply(ctx));
+    runset(getSpec(primary(), "preparePath", "basic"), (entry) -> {
+      Map<String, Object> ctxmap = Helpers.toMapAny(entry.get("ctx"));
+      Context ctx = makeCtxFromMap(ctxmap, client, utility);
+      return utility.preparePath.apply(ctx);
+    });
   }
 
   @Test

package/project/.sdk/tm/js/Makefile

@@ -10,23 +10,23 @@ clean:
 	rm -rf node_modules
 
 # --- Release: publish to npm ----------------------------------------------
-# Publish this package to npm, then tag js/vX.Y.Z. Run headless under the aql
+# Publish this package to npm, then tag js/vX.Y.Z. Run headless under the boru
 # key vault, which injects the npm auth token + the GitHub token (never on disk
 # or argv):
-#   aql vault exec --for=npm=<alias> --for=github=<alias> -- make publish
-# aql `--dry-run` injects a filler token we detect to rehearse (no publish/tag).
+#   boru vault exec --for=npm=<alias> --for=github=<alias> -- make publish
+# boru `--dry-run` injects a filler token we detect to rehearse (no publish/tag).
 # set -e + tag-last: a failed publish never leaves a tag behind.
 SHELL := /bin/bash
 VERSION := $(shell node -p "require('./package.json').version")
 TAG := js/v$(VERSION)
-AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+BORU_DRY_RUN_FILLER := BORU-DRY-RUN-FILLER-NOT-A-REAL-SECRET
 publish: test
 	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
 	  echo "tag $(TAG) already exists — bump package.json version first"; exit 1; fi
 	@set -e; \
 	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
-	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
-	  echo "[dry-run] aql filler token detected: would publish to npm and tag $(TAG); nothing pushed."; \
+	if [ "$$token" = "$(BORU_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] boru filler token detected: would publish to npm and tag $(TAG); nothing pushed."; \
 	  exit 0; \
 	fi; \
 	npm stage publish --access public --registry https://registry.npmjs.org; \

package/project/.sdk/tm/js/src/feature/test/TestFeature.js

@@ -49,12 +49,29 @@ class TestFeature extends BaseFeature {
       const delprop = struct.delprop
       const getdef = struct.getdef
 
+      // Shape the mock payload the way the real API would, so the op's
+      // response transform recovers the entity from it. A point carrying
+      // `transform.res: \`body.item\`` describes an API that answers
+      // `{item: {...}}`; handing back the bare entity means the transform
+      // unwraps a property that is not there and the caller gets undefined.
+      // The mock has to agree with the model, or it only ever simulates APIs
+      // whose responses happen to be unwrapped.
+      function envelope(data) {
+        const restf = getprop(getprop(ctx.point, 'transform', {}), 'res')
+        if (null == data || 'string' !== typeof restf) {
+          return data
+        }
+        const m = restf.match(/^`body\.([^`.]+)`$/)
+        return null == m ? data : { [m[1]]: data }
+      }
+
       function respond(status, data, res) {
+        const payload = envelope(data)
         const out = merge([
           {
             status,
             statusText: 'OK',
-            json: async () => data,
+            json: async () => payload,
             body: 'not-used',
           },
           getdef(res, {})

package/project/.sdk/tm/js/src/utility/MakeOptionsUtility.js

@@ -79,16 +79,54 @@ function makeOptions(ctx) {
     },
     clean: {
       keys: 'key,token,id'
+    },
+    // Server-variable values for a templated base URL (OpenAPI server
+    // variables): `{name}` placeholders in `base` are substituted from
+    // this map at construction. Spec defaults arrive via the generated
+    // Config; user values override them.
+    server: {
+      '`$CHILD`': ''
     }
   }
 
   // JavaScript specific option values.
   optspec.system.fetch = opts.system?.fetch || global.fetch
 
-  opts = merge([{}, cfgopts, opts])
+  // Clone the config side before merging: `config` is a module-level
+  // singleton in ts/js, and merge would otherwise use its nested maps as
+  // merge TARGETS — one instance's options (server, headers, ...) would
+  // contaminate every instance constructed after it.
+  opts = merge([{}, struct.clone(cfgopts), opts])
 
   opts = validate(opts, optspec)
 
+  // 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 construction ERROR in live mode — the URL cannot
+  // work — but in test mode substitutes the deterministic value
+  // `test-<name>` so offline tests need no configuration.
+  if ('string' === typeof opts.base && opts.base.includes('{')) {
+    const testmode = true === opts.test.active ||
+      true === (opts.feature && opts.feature.test && opts.feature.test.active)
+    const server = opts.server || {}
+    opts.base = opts.base.replace(/\{([A-Za-z0-9_]+)\}/g,
+      (_m, name) => {
+        let val = server[name]
+        val = 'string' === typeof val ? val : ''
+        if ('' === val) {
+          if (testmode) {
+            return 'test-' + name
+          }
+          throw new Error(
+            (config?.main?.name || 'SDK') + ": the server variable '" + name +
+            "' is required: the API base URL is '" + opts.base +
+            "' — pass { server: { " + name + ": '...' } } in the SDK options")
+        }
+        return val
+      })
+  }
+
   // Resolve the feature add-order: an explicit array order (above) wins;
   // otherwise order the map test-first, then the remaining names sorted, so
   // the outcome is deterministic and `test` is always the base transport.

package/project/.sdk/tm/js/test/utility/PrimaryUtility.test.js

@@ -96,6 +96,14 @@ describe('PrimaryUtility', async () => {
   })
 
 
+  // preparePath shipped as an empty `set: []`, so no port drove it and several
+  // kept private hand-written cases instead. Corpus-driven like every other
+  // section now.
+  test('path-basic', async () => {
+    await runset(spec.preparePath.basic, utility.preparePath)
+  })
+
+
   test('body-basic', async () => {
     await runset(spec.prepareBody.basic, (ctx) => {
       fixctx(ctx)
@@ -197,6 +205,9 @@ describe('PrimaryUtility', async () => {
       body: 'present',
     })
     const reqClient = new SDK({
+      // 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: { fetch: mockFetch }
     })
     const reqUtility = reqClient.utility()
@@ -378,6 +389,7 @@ describe('PrimaryUtility', async () => {
   test('fetcher-live', async () => {
     const calls = []
     const liveClient = new SDK({
+      base: 'http://localhost:8080',
       system: {
         fetch: async (url, init) => {
           calls.push({ url, init })
@@ -399,6 +411,7 @@ describe('PrimaryUtility', async () => {
 
   test('fetcher-blocked-test-mode', async () => {
     const blockedClient = new SDK({
+      base: 'http://localhost:8080',
       system: { fetch: async () => ({}) }
     })
     blockedClient._mode = 'test'

package/project/.sdk/tm/kotlin/Makefile

@@ -16,20 +16,20 @@ clean:
 # --- Release: tag kotlin/vX.Y.Z ---------------------------------------------
 # Maven Central publication (Sonatype Central Portal) is pending for this
 # target; publishing a version currently means pushing the kotlin/vX.Y.Z git
-# tag. Run headless under the aql key vault, which injects the GitHub token
+# tag. Run headless under the boru key vault, which injects the GitHub token
 # so nothing lands on disk or argv:
-#   aql vault exec --for=github=<alias> -- make publish
-# aql `--dry-run` injects a filler token we detect to rehearse (no tag/push).
+#   boru vault exec --for=github=<alias> -- make publish
+# boru `--dry-run` injects a filler token we detect to rehearse (no tag/push).
 VERSION := $(shell cat VERSION)
 TAG := kotlin/v$(VERSION)
-AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+BORU_DRY_RUN_FILLER := BORU-DRY-RUN-FILLER-NOT-A-REAL-SECRET
 publish:
 	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
 	  echo "tag $(TAG) already exists — bump VERSION first"; exit 1; fi
 	@set -e; \
 	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
-	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
-	  echo "[dry-run] aql filler token detected: would tag $(TAG); nothing pushed."; \
+	if [ "$$token" = "$(BORU_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] boru filler token detected: would tag $(TAG); nothing pushed."; \
 	  exit 0; \
 	fi; \
 	git tag -a "$(TAG)" -m "kotlin v$(VERSION)"; \