@voxgig/sdkgen 1.3.17 → 1.3.19

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

@@ -176,6 +176,9 @@ class PrimaryUtilityTest < Minitest::Test
   def test_fetcher_live
     calls = []
     live_client = ProjectNameSDK.new({
+      # 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" => ->(url, fetchdef) {
           calls << { "url" => url, "init" => fetchdef }
@@ -199,6 +202,7 @@ class PrimaryUtilityTest < Minitest::Test
 
   def test_fetcher_blocked_test_mode
     blocked_client = ProjectNameSDK.new({
+      "base" => "http://localhost:8080",
       "system" => {
         "fetch" => ->(url, fetchdef) {
           return {}, nil
@@ -610,14 +614,13 @@ class PrimaryUtilityTest < Minitest::Test
   # === preparePath ===
 
   def test_prepare_path_basic
-    ctx = make_test_full_ctx(@client, @utility)
-    ctx.point = {
-      "parts" => ["api", "planet", "{id}"],
-      "args" => { "params" => [] },
-    }
-
-    path = @utility.prepare_path.call(ctx)
-    assert_equal "api/planet/{id}", path
+    # Was hand-written cases that had drifted out of the shared corpus
+    # (the preparePath fixture shipped as an empty `set: []`).
+    runset(get_spec(@primary, "preparePath", "basic")) do |entry|
+      ctxmap = entry["ctx"] || {}
+      ctx = make_ctx_from_map(ctxmap, @client, @utility)
+      @utility.prepare_path.call(ctx)
+    end
   end
 
   def test_prepare_path_single

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

@@ -52,6 +52,11 @@ module ProjectNameUtilities
       "system" => {},
       "test" => { "active" => false, "entity" => { "`$OPEN`" => true } },
       "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`" => "" },
     }
 
     sys_fetch = VoxgigStruct.getpath(opts, "system.fetch")
@@ -60,6 +65,38 @@ module ProjectNameUtilities
     validated = VoxgigStruct.validate(merged, optspec)
     opts = validated.is_a?(Hash) ? validated : {}
 
+    # 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.
+    base = opts["base"]
+    if base.is_a?(String) && base.include?("{")
+      testmode = VoxgigStruct.getpath(opts, "test.active") == true ||
+        VoxgigStruct.getpath(opts, "feature.test.active") == true
+      server = opts["server"].is_a?(Hash) ? opts["server"] : {}
+      sdkname = VoxgigStruct.getpath(config, "main.name")
+      sdkname = "SDK" unless sdkname.is_a?(String) && !sdkname.empty?
+      opts["base"] = base.gsub(/\{([A-Za-z0-9_]+)\}/) do
+        name = Regexp.last_match(1)
+        val = server[name]
+        val = "" unless val.is_a?(String)
+        if val.empty?
+          if testmode
+            "test-#{name}"
+          else
+            raise ArgumentError,
+              "#{sdkname}: the server variable '#{name}' is required: " \
+              "the API base URL is '#{base}' — pass " \
+              "{ \"server\" => { \"#{name}\" => \"...\" } } in the SDK options"
+          end
+        else
+          val
+        end
+      end
+    end
+
     if sys_fetch
       opts["system"] = {} unless opts["system"].is_a?(Hash)
       opts["system"]["fetch"] = sys_fetch

package/project/.sdk/tm/rust/Makefile

@@ -13,21 +13,21 @@ clean:
 # The crates.io registry entry is declared in the model with
 # state: 'pending' — a real deploy publishes the git tag rust/vX.Y.Z only;
 # `cargo publish` starts when the registry state flips to 'active'. Run
-# headless under the aql key vault, which injects the GitHub token so
+# 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.
 VERSION := $(shell cat VERSION)
 TAG := rust/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 "rust v$(VERSION)"; \

package/project/.sdk/tm/rust/tests/common/mod.rs

@@ -291,15 +291,51 @@ pub fn match_deep(check: &Value, base: &Value) -> Option<String> {
 
 // ---- runset (mirrors go runner_test.go runset) -----------------------------------
 
+// Sections deliberately left empty in the shared corpus
+// (.sdk/test/primary/<name>.aontu carries a PENDING header). Everything else
+// MUST contribute cases.
+pub const PENDING_SECTIONS: &[&str] = &[
+    "fetcher", "makeFetchDef", "makePoint", "makeResult", "featureAdd",
+    "featureHook", "featureInit",
+];
+
 pub fn runset(
     testspec: &Value,
     subject: &mut dyn FnMut(&Value) -> Result<Value, ProjectNameError>,
+) {
+    runset_named("", testspec, subject)
+}
+
+/// Drive one section of the shared test corpus.
+///
+/// This 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 now panic, except for the
+/// sections explicitly marked PENDING in the corpus.
+pub fn runset_named(
+    name: &str,
+    testspec: &Value,
+    subject: &mut dyn FnMut(&Value) -> Result<Value, ProjectNameError>,
 ) {
     let set = match getp(testspec, "set") {
         Value::List(l) => Value::List(l),
-        _ => return,
+        _ => panic!(
+            "test corpus section {:?} has no `set` list — zero cases would run",
+            name
+        ),
     };
 
+    if let Value::List(l) = &set {
+        if l.borrow().is_empty() && !PENDING_SECTIONS.contains(&name) {
+            panic!(
+                "test corpus section {:?} is EMPTY — zero cases would run; add \
+                 cases, or mark the fixture PENDING in .sdk/test/primary/",
+                name
+            );
+        }
+    }
+
     let entries: Vec<Value> = match &set {
         Value::List(l) => l.borrow().clone(),
         _ => Vec::new(),

package/project/.sdk/tm/rust/tests/primary_utility_test.rs

@@ -810,35 +810,21 @@ fn primary_prepare_params_basic() {
     );
 }
 
+// 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.
 #[test]
 fn primary_prepare_path_basic() {
     let (client, utility) = base_client();
-    let ctx = make_test_full_ctx(&client, &utility);
-    *ctx.point.borrow_mut() = jo(vec![
-        (
-            "parts",
-            ja(vec![
-                Value::str("api"),
-                Value::str("planet"),
-                Value::str("{id}"),
-            ]),
-        ),
-        ("args", jo(vec![("params", Value::empty_list())])),
-    ]);
-
-    assert_eq!(utility.prepare_path(&ctx), "api/planet/{id}");
-}
-
-#[test]
-fn primary_prepare_path_single() {
-    let (client, utility) = base_client();
-    let ctx = make_test_full_ctx(&client, &utility);
-    *ctx.point.borrow_mut() = jo(vec![
-        ("parts", ja(vec![Value::str("items")])),
-        ("args", jo(vec![("params", Value::empty_list())])),
-    ]);
-
-    assert_eq!(utility.prepare_path(&ctx), "items");
+    let primary = primary();
+    runset(
+        &get_spec(&primary, &["preparePath", "basic"]),
+        &mut |entry| {
+            let ctx = make_ctx_from_map(&getp(entry, "ctx"), &client, &utility);
+            Ok(Value::str(utility.prepare_path(&ctx)))
+        },
+    );
 }
 
 #[test]

package/project/.sdk/tm/swift/Makefile

@@ -13,21 +13,21 @@ clean:
 # --- Release: tag for the SwiftPM registry ---------------------------------
 # SwiftPM has no upload step - publishing IS the git tag. Publication is
 # pending (see model/target/swift.aontu publish block); publishing a version
-# currently means pushing the tag swift/vX.Y.Z. Run headless under the aql key
+# currently means pushing the tag swift/vX.Y.Z. 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.
 VERSION := $(shell cat VERSION)
 TAG := swift/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 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 "swift v$(VERSION)"; \

package/project/.sdk/tm/swift/Tests/ProjectNameSDKTests/PrimaryUtilityTest.swift

@@ -629,14 +629,13 @@ final class PrimaryUtilityTest: XCTestCase {
   }
 
   func testPreparePathBasic() {
-    let ctx = makeTestFullCtx(client, utility)
-    ctx.point = vm(
-      ("parts", .list([.string("api"), .string("planet"), .string("{id}")])),
-      ("args", .map(vm(("params", .list([])))))
-    )
-
-    let path = utility.preparePath(ctx)
-    XCTAssertEqual(path, "api/planet/{id}")
+    // Was hand-written cases that had drifted out of the shared corpus
+    // (the preparePath fixture shipped as an empty `set: []`).
+    SdkRunner.runSet(SdkRunner.spec(primary, "preparePath", "basic")) { entry in
+      let ctxmap = entry.entries["ctx"]?.asMap
+      let ctx = SdkRunner.makeCtxFromMap(ctxmap, self.client, self.utility)
+      return .string(self.utility.preparePath(ctx))
+    }
   }
 
   func testPreparePathSingle() {

package/project/.sdk/tm/ts/Makefile

@@ -17,22 +17,22 @@ clean:
 
 # --- Release: publish to npm ----------------------------------------------
 # Compile, then publish this package to npm and tag ts/vX.Y.Z. Run headless
-# under the aql key vault, which injects the npm auth token + the GitHub token
+# 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 (build only, no
+#   boru vault exec --for=npm=<alias> --for=github=<alias> -- make publish
+# boru `--dry-run` injects a filler token we detect to rehearse (build only, 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 := ts/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/ts/src/feature/test/TestFeature.ts

@@ -52,12 +52,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: any) {
+        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: number, data?: any, res?: any) {
+        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/ts/src/utility/MakeOptionsUtility.ts

@@ -82,16 +82,54 @@ function makeOptions(ctx: Context) {
     },
     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: string, name: string) => {
+        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/ts/test/utility/PrimaryUtility.test.ts

@@ -31,6 +31,38 @@ describe('PrimaryUtility', async () => {
   }
 
 
+  // Sections deliberately left empty in the shared corpus
+  // (.sdk/test/primary/<name>.aontu carries a PENDING header). Everything
+  // else MUST contribute cases.
+  const PENDING = new Set([
+    'fetcher', 'makeFetchDef', 'makePoint', 'makeResult',
+    'featureAdd', 'featureHook', 'featureInit',
+  ])
+
+  // Run one corpus section, failing loudly when it would run ZERO cases.
+  // A renamed section or a fixture that compiled to an empty `set` used to
+  // pass silently, which defeats the point of a shared oracle. (The guard
+  // lives here rather than in runner.ts, which is vendored verbatim from
+  // @voxgig/struct and must stay byte-identical to upstream.)
+  //
+  // EVERY corpus-backed test goes through here — a guard that only some
+  // sections opt into leaves the rest able to run zero assertions, which is
+  // the exact hole it was added to close.
+  async function runsection(name: string, subject: Function) {
+    const section = spec[name]
+    ok(null != section,
+      `test corpus section '${name}' missing — check the name against .sdk/test/primary/`)
+    ok(null != section.basic && Array.isArray(section.basic.set),
+      `test corpus section '${name}' has no basic.set list`)
+    if (0 === section.basic.set.length && !PENDING.has(name)) {
+      throw new Error(
+        `test corpus section '${name}' is EMPTY — zero cases would run; ` +
+        `add cases, or mark the fixture PENDING in .sdk/test/primary/`)
+    }
+    return runset(section.basic, subject)
+  }
+
+
   before(async () => {
     const runner = await makeRunner(TEST_JSON_FILE, await SDK.test())
     const run = await runner('primary')
@@ -61,24 +93,24 @@ describe('PrimaryUtility', async () => {
 
 
   test('context-basic', async () => {
-    await runset(spec.makeContext.basic, utility.makeContext)
+    await runsection('makeContext', utility.makeContext)
   })
 
 
   test('method-basic', async () => {
-    await runset(spec.prepareMethod.basic, utility.prepareMethod)
+    await runsection('prepareMethod', utility.prepareMethod)
   })
 
 
   test('headers-basic', async () => {
-    await runset(spec.prepareHeaders.basic, utility.prepareHeaders)
+    await runsection('prepareHeaders', utility.prepareHeaders)
   })
 
 
   test('auth-basic', async () => {
     const sdkopts = spec.prepareAuth?.DEF?.setup?.a || {}
     const authClient = SDK.test({}, sdkopts)
-    await runset(spec.prepareAuth.basic, (ctx: any) => {
+    await runsection('prepareAuth', (ctx: any) => {
       ctx.client = authClient
       fixctx(ctx)
       return utility.prepareAuth(ctx)
@@ -87,17 +119,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('params-basic', async () => {
-    await runset(spec.prepareParams.basic, utility.prepareParams)
+    await runsection('prepareParams', utility.prepareParams)
   })
 
 
   test('query-basic', async () => {
-    await runset(spec.prepareQuery.basic, utility.prepareQuery)
+    await runsection('prepareQuery', utility.prepareQuery)
   })
 
 
   test('body-basic', async () => {
-    await runset(spec.prepareBody.basic, (ctx: any) => {
+    await runsection('prepareBody', (ctx: any) => {
       fixctx(ctx)
       return utility.prepareBody(ctx)
     })
@@ -105,17 +137,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('findparam-basic', async () => {
-    await runset(spec.param.basic, utility.param)
+    await runsection('param', utility.param)
   })
 
 
   test('fullurl-basic', async () => {
-    await runset(spec.makeUrl.basic, utility.makeUrl)
+    await runsection('makeUrl', utility.makeUrl)
   })
 
 
   test('operator-basic', async () => {
-    await runset(spec.operator.basic, (opmap: any) => ({
+    await runsection('operator', (opmap: any) => ({
       entity: opmap.entity || '_',
       name: opmap.name || '_',
       input: opmap.input || '_',
@@ -125,7 +157,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('options-basic', async () => {
-    await runset(spec.makeOptions.basic, (vin: any) => {
+    await runsection('makeOptions', (vin: any) => {
       const ctx = utility.makeContext({ options: vin.options, config: vin.config })
       ctx.client = client
       ctx.utility = utility
@@ -137,7 +169,7 @@ describe('PrimaryUtility', async () => {
   test('spec-basic', async () => {
     const sdkopts = spec.makeSpec?.DEF?.setup?.a || {}
     const specClient = SDK.test({}, sdkopts)
-    await runset(spec.makeSpec.basic, (ctx: any) => {
+    await runsection('makeSpec', (ctx: any) => {
       ctx.client = specClient
       ctx.options = specClient.options()
       return utility.makeSpec(ctx)
@@ -146,17 +178,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('reqform-basic', async () => {
-    await runset(spec.transformRequest.basic, utility.transformRequest)
+    await runsection('transformRequest', utility.transformRequest)
   })
 
 
   test('resform-basic', async () => {
-    await runset(spec.transformResponse.basic, utility.transformResponse)
+    await runsection('transformResponse', utility.transformResponse)
   })
 
 
   test('resbasic-basic', async () => {
-    await runset(spec.resultBasic.basic, (ctx: any) => {
+    await runsection('resultBasic', (ctx: any) => {
       fixctx(ctx)
       return utility.resultBasic(ctx)
     })
@@ -164,7 +196,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('resheaders-basic', async () => {
-    await runset(spec.resultHeaders.basic, (ctx: any) => {
+    await runsection('resultHeaders', (ctx: any) => {
       // Convert plain headers map to forEach-based (browser Response API)
       if (ctx.response?.headers && !ctx.response.headers.forEach) {
         const h = ctx.response.headers
@@ -178,7 +210,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('resbody-basic', async () => {
-    await runset(spec.resultBody.basic, async (ctx: any) => {
+    await runsection('resultBody', async (ctx: any) => {
       if (ctx.response && !ctx.response.json) {
         const body = ctx.response.body
         ctx.response.json = async () => body
@@ -197,10 +229,12 @@ describe('PrimaryUtility', async () => {
       body: 'present',
     })
     const reqClient = new (SDK as 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: { fetch: mockFetch }
     })
     const reqUtility = reqClient.utility()
-    await runset(spec.makeRequest.basic, async (ctx: any) => {
+    await runsection('makeRequest', async (ctx: any) => {
       ctx.client = reqClient
       ctx.utility = reqUtility
       ctx.options = reqClient.options()
@@ -210,7 +244,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('response-basic', async () => {
-    await runset(spec.makeResponse.basic, async (ctx: any) => {
+    await runsection('makeResponse', async (ctx: any) => {
       fixctx(ctx)
       // Add json() and forEach to response for proper TS handling
       if (ctx.response && !ctx.response.json) {
@@ -229,7 +263,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('done-basic', async () => {
-    await runset(spec.done.basic, (ctx: any) => {
+    await runsection('done', (ctx: any) => {
       fixctx(ctx)
       return utility.done(ctx)
     })
@@ -237,7 +271,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('error-basic', async () => {
-    await runset(spec.makeError.basic, (...args: any[]) => {
+    await runsection('makeError', (...args: any[]) => {
       const ctx = args[0]
       fixctx(ctx)
       return utility.makeError(...args)
@@ -378,6 +412,7 @@ describe('PrimaryUtility', async () => {
   test('fetcher-live', async () => {
     const calls: any[] = []
     const liveClient = new (SDK as any)({
+      base: 'http://localhost:8080',
       system: {
         fetch: async (url: string, init: any) => {
           calls.push({ url, init })
@@ -399,6 +434,7 @@ describe('PrimaryUtility', async () => {
 
   test('fetcher-blocked-test-mode', async () => {
     const blockedClient = new (SDK as any)({
+      base: 'http://localhost:8080',
       system: { fetch: async () => ({}) }
     })
     blockedClient._mode = 'test'
@@ -424,6 +460,18 @@ describe('PrimaryUtility', async () => {
   })
 
 
+  test('path-basic', async () => {
+    // preparePath shipped as an empty `set: []` — every port "passed" it while
+    // running zero cases. Now corpus-driven like every other section.
+    await runsection('preparePath', (ctx: any) => utility.preparePath(ctx))
+  })
+
+
+  test('clean-corpus', async () => {
+    await runsection('clean', (...args: any[]) => utility.clean(args[0], args[1]))
+  })
+
+
   test('clean', () => {
     const ctx = makeFullCtx()
     const val = { key: 'secret123', name: 'test' }