@voxgig/sdkgen 4.2.3 → 4.2.5

package/project/.sdk/src/cmp/rust/ReadmeQuick_rust.ts

@@ -7,7 +7,7 @@ import {
   nom,
 } from '@voxgig/apidef'
 
-import { crateIdent, rustVarName } from './utility_rust'
+import { crateIdent, rustVarName, rustMethodName } from './utility_rust'
 
 
 const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
@@ -58,7 +58,7 @@ let client = ${ctor};
     const eName = nom(exampleEntity, 'Name')
     const article = /^[aeiou]/i.test(eName) ? 'an' : 'a'
     const eVar = rustVarName(exampleEntity.name)
-    const method = rustVarName(exampleEntity.name)
+    const method = rustMethodName(exampleEntity.name)
     const opnames = entityOps(exampleEntity)
     // Model-driven id key: `idF` is the entity's id-like MATCH field name, or
     // null. `dataIdF` is the id on the RETURNED record's data type.
@@ -91,7 +91,7 @@ match client.${method}(Value::Noval).list(Value::Noval, Value::Noval) {
       const neName = nom(nestedEntity, 'Name')
       const neArticle = /^[aeiou]/i.test(neName) ? 'an' : 'a'
       const neVar = rustVarName(nestedEntity.name)
-      const neMethod = rustVarName(nestedEntity.name)
+      const neMethod = rustMethodName(nestedEntity.name)
 
       const neIdF = entityIdField(nestedEntity)
       const neRequired = opRequestShape(nestedEntity, 'load').items

package/project/.sdk/src/cmp/rust/ReadmeRef_rust.ts

@@ -6,7 +6,7 @@ import {
   getModelPath,
 } from '@voxgig/apidef'
 
-import { crateIdent, rustVarName } from './utility_rust'
+import { crateIdent, rustVarName, rustMethodName } from './utility_rust'
 
 
 // Type names come from the shared canonToType 'rust' column (single source of truth).
@@ -120,7 +120,7 @@ let client = test_sdk(Value::Noval, Value::Noval);
 
     // Entity factory methods
     publishedEntities.map((ent: any) => {
-      Content(`#### \`${rustVarName(ent.name)}(entopts: Value) -> Rc<${ent.Name}Entity>\`
+      Content(`#### \`${rustMethodName(ent.name)}(entopts: Value) -> Rc<${ent.Name}Entity>\`
 
 Create a new \`${ent.Name}Entity\` instance. Pass \`Value::Noval\` for no
 initial options.
@@ -168,7 +168,7 @@ Prepare a fetch definition without sending. Returns the fetchdef on \`Ok\`.
       const fields = ent.fields || []
       const idF = entityIdField(ent)
       const eVar = rustVarName(ent.name)
-      const method = rustVarName(ent.name)
+      const method = rustMethodName(ent.name)
 
       Content(`
 ---

package/project/.sdk/src/cmp/rust/ReadmeTopQuick_rust.ts

@@ -7,7 +7,7 @@ import {
   nom,
 } from '@voxgig/apidef'
 
-import { crateIdent, rustVarName } from './utility_rust'
+import { crateIdent, rustVarName, rustMethodName } from './utility_rust'
 
 
 // A type-correct rust expression constructing a voxgig struct Value for a
@@ -46,7 +46,7 @@ let client = ${ctor};
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
     const eVar = rustVarName(exampleEntity.name)
-    const method = rustVarName(exampleEntity.name)
+    const method = rustMethodName(exampleEntity.name)
     const opnames = Object.keys(exampleEntity.op || {})
     // Model-driven id key: null when the entity has no id-like field, in which
     // case the load example takes no match argument.

package/project/.sdk/src/cmp/rust/ReadmeTopTest_rust.ts

@@ -7,7 +7,7 @@ import {
   nom,
 } from '@voxgig/apidef'
 
-import { crateIdent, rustVarName } from './utility_rust'
+import { crateIdent, rustVarName, rustMethodName } from './utility_rust'
 
 
 // A type-correct rust expression constructing a voxgig struct Value for a
@@ -40,7 +40,7 @@ let client = test_sdk(Value::Noval, Value::Noval);
 
   if (exampleEntity && primaryOp) {
     const eName = nom(exampleEntity, 'Name')
-    const method = rustVarName(exampleEntity.name)
+    const method = rustMethodName(exampleEntity.name)
     const idF = entityIdField(exampleEntity)
     const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
     let arg = 'Value::Noval'

package/project/.sdk/src/cmp/rust/TestEntity_rust.ts

@@ -21,7 +21,7 @@ import {
 } from '@voxgig/sdkgen'
 
 
-import { rustVarName } from './utility_rust'
+import { rustVarName, rustMethodName } from './utility_rust'
 
 
 // Rust's GenCtx mirrors the shared shape (see TestEntity_ts.ts) plus the
@@ -100,7 +100,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
     }
 `
 
-  const method = rustVarName(entity.name)
+  const method = rustMethodName(entity.name)
   const evar = rustVarName(entity.name)
 
   File({ name: entity.name + '_entity_test.' + target.ext }, () => {
@@ -330,7 +330,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
   Content(`    // CREATE
 `)
   if (needsEnt) {
-    Content(`    let ${entvar} = client.${rustVarName(entity.name)}(Value::Noval);
+    Content(`    let ${entvar} = client.${rustMethodName(entity.name)}(Value::Noval);
 `)
   }
 
@@ -381,7 +381,7 @@ const generateList: OpGen = (ctx, step, index) => {
   Content(`    // LIST
 `)
   if (needsEnt) {
-    Content(`    let ${entvar} = client.${rustVarName(entity.name)}(Value::Noval);
+    Content(`    let ${entvar} = client.${rustMethodName(entity.name)}(Value::Noval);
 `)
   }
 
@@ -464,7 +464,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
   Content(`    // UPDATE
 `)
   if (needsEnt) {
-    Content(`    let ${entvar} = client.${rustVarName(entity.name)}(Value::Noval);
+    Content(`    let ${entvar} = client.${rustMethodName(entity.name)}(Value::Noval);
 `)
   }
   Content(`    let ${datavar}_up = Value::empty_map();
@@ -568,7 +568,7 @@ const generateLoad: OpGen = (ctx, step, index) => {
   Content(`    // LOAD
 `)
   if (!hasEntVar) {
-    Content(`    let ${entvar} = client.${rustVarName(entity.name)}(Value::Noval);
+    Content(`    let ${entvar} = client.${rustMethodName(entity.name)}(Value::Noval);
 `)
   }
   if (!hasSrcData && hasEntId) {
@@ -626,7 +626,7 @@ const generateRemove: OpGen = (ctx, step, index) => {
   Content(`    // REMOVE
 `)
   if (needsEnt) {
-    Content(`    let ${entvar} = client.${rustVarName(entity.name)}(Value::Noval);
+    Content(`    let ${entvar} = client.${rustMethodName(entity.name)}(Value::Noval);
 `)
   }
   // Always match the prior-created entity by id to avoid mock-order flakes.

package/project/.sdk/src/cmp/swift/EntityTypes_swift.ts

@@ -32,7 +32,7 @@ import {
   getModelPath,
 } from '@voxgig/apidef'
 
-import { swiftVarName } from './utility_swift'
+import { swiftVarName , swiftTargetDir, swiftTestDir } from './utility_swift'
 
 
 const LANG = 'swift'
@@ -89,7 +89,7 @@ const EntityTypes = cmp(function EntityTypes(props: any) {
   warnEntityTypeCollisions(entity, log, LANG)
 
   Folder({ name: 'Sources' }, () => {
-    Folder({ name: 'ProjectNameSDK' }, () => {
+    Folder({ name: swiftTargetDir(model) }, () => {
       Folder({ name: 'entity' }, () => {
 
         File({ name: model.const.Name + 'Types.' + target.ext }, () => {

package/project/.sdk/src/cmp/swift/Entity_swift.ts

@@ -1,6 +1,8 @@
 
 import * as Path from 'node:path'
 
+import { swiftTargetDir, swiftTestDir } from './utility_swift'
+
 import {
   cmp, camelify, names,
   Content, File, Folder, Fragment,
@@ -33,7 +35,7 @@ const Entity = cmp(function Entity(props: any) {
 
   // Entity files join the copied runtime under Sources/ProjectNameSDK/entity.
   Folder({ name: 'Sources' }, () => {
-    Folder({ name: 'ProjectNameSDK' }, () => {
+    Folder({ name: swiftTargetDir(model) }, () => {
       Folder({ name: 'entity' }, () => {
 
         File({ name: cls + '.' + target.ext }, () => {

package/project/.sdk/src/cmp/swift/Main_swift.ts

@@ -1,6 +1,8 @@
 
 import * as Path from 'node:path'
 
+import { swiftTargetDir, swiftTestDir } from './utility_swift'
+
 import {
   cmp, each,
   File, Content, Copy, Folder, Fragment,
@@ -40,18 +42,51 @@ const Main = cmp(async function Main(props: any) {
 
   // Copy tm/swift files with replacements. `src/` holds only the per-feature
   // extension folders (not shipped into the SDK output).
+  // THE COPIED TREE HAS TO CARRY THE API NAME TOO.
+  //
+  // Copy substitutes file CONTENTS, never path components, so a blanket copy
+  // of tm/swift landed the runtime in a directory literally called
+  // ProjectNameSDK. Package.swift papered over it with an explicit `path:`,
+  // so it compiled and every swift suite passed — while every published SDK
+  // shipped `Sources/ProjectNameSDK/`, and SwiftPM's own convention
+  // (Sources/<target>) was broken in all of them.
+  //
+  // Copy's `to` prop names the destination, so the two placeholder subtrees
+  // are copied explicitly and the rest of tm/swift blanket-copied as before.
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//],
+    exclude: [/src\//, /Sources\//, /Tests\//],
     replace: {
       ...props.ctx$.stdrep,
       ProjectName: model.const.Name,
     }
   })
 
+  Folder({ name: 'Sources' }, () => {
+    Copy({
+      from: 'tm/' + target.name + '/Sources/ProjectNameSDK',
+      to: swiftTargetDir(model),
+      replace: {
+        ...props.ctx$.stdrep,
+        ProjectName: model.const.Name,
+      }
+    })
+  })
+
+  Folder({ name: 'Tests' }, () => {
+    Copy({
+      from: 'tm/' + target.name + '/Tests/ProjectNameSDKTests',
+      to: swiftTestDir(model),
+      replace: {
+        ...props.ctx$.stdrep,
+        ProjectName: model.const.Name,
+      }
+    })
+  })
+
   // Generated sources join the copied runtime under Sources/ProjectNameSDK.
   Folder({ name: 'Sources' }, () => {
-    Folder({ name: 'ProjectNameSDK' }, () => {
+    Folder({ name: swiftTargetDir(model) }, () => {
       Folder({ name: 'core' }, () => {
 
         // Main SDK client class, with entity accessors injected at the SLOT.

package/project/.sdk/src/cmp/swift/Package_swift.ts

@@ -1,4 +1,6 @@
 
+import { swiftTargetDir, swiftTestDir } from './utility_swift'
+
 import {
   Content,
   File,
@@ -14,10 +16,11 @@ import type {
 
 // Emits Package.swift (the SwiftPM manifest; the Swift twin of Package_go's
 // go.mod / Package_csharp's csproj). The library target compiles everything
-// under Sources/ProjectNameSDK (the copied runtime + generated sources); the
-// test target compiles Tests/ProjectNameSDKTests. Directory names are the
-// verbatim copied paths (Copy does not rewrite path components); the target
-// NAMES carry the API name.
+// under Sources/<Name>Sdk (the copied runtime + generated sources); the test
+// target compiles Tests/<Name>SdkTests. Both directories carry the API name:
+// Copy does not rewrite path components, so Main_swift copies the two
+// placeholder subtrees explicitly via Copy's `to` prop rather than letting a
+// blanket copy ship them as ProjectNameSDK.
 //
 // Dependencies: the runtime itself is dependency-free (Foundation + the
 // vendored struct), but declared target/feature deps flow into the manifest
@@ -91,11 +94,11 @@ let package = Package(
     targets: [
         .target(
             name: "${Name}Sdk",${targetdeps}
-            path: "Sources/ProjectNameSDK"),
+            path: "Sources/${swiftTargetDir(model)}"),
         .testTarget(
             name: "${Name}SdkTests",
             dependencies: ["${Name}Sdk"],
-            path: "Tests/ProjectNameSDKTests"),
+            path: "Tests/${swiftTestDir(model)}"),
     ]
 )
 `)

package/project/.sdk/src/cmp/swift/ReadmeExamplesTest_swift.ts

@@ -64,7 +64,7 @@ final class ReadmeExamplesTest: XCTestCase {
   // The three documents to scan, resolved relative to this test file.
   private func docs() -> [Doc] {
     let here = URL(fileURLWithPath: #filePath)
-      .deletingLastPathComponent()   // ProjectNameSDKTests
+      .deletingLastPathComponent()   // the test target dir
       .deletingLastPathComponent()   // Tests
       .deletingLastPathComponent()   // swift (module dir)
     let project = here.deletingLastPathComponent()  // project (holds root README)

package/project/.sdk/src/cmp/swift/ReadmeExplanation_swift.ts

@@ -1,4 +1,6 @@
 
+import { swiftTargetDir, swiftTestDir } from './utility_swift'
+
 import { cmp, Content } from '@voxgig/sdkgen'
 
 
@@ -24,16 +26,16 @@ generated for editor documentation.
 \`\`\`
 swift/
 ├── Package.swift                     -- SwiftPM manifest (zero runtime deps)
-├── Sources/ProjectNameSDK/
+├── Sources/${swiftTargetDir(model)}/
 │   ├── core/                         -- Main client, config, entity base, error type
 │   ├── entity/                       -- Generated entity clients
 │   ├── feature/                      -- Built-in features (Base, Test, Log, ...)
 │   ├── utility/                      -- Utility functions
 │   └── Struct/                       -- Vendored Voxgig Struct port
-└── Tests/ProjectNameSDKTests/        -- Test suites (XCTest)
+└── Tests/${swiftTestDir(model)}/    -- Test suites (XCTest)
 \`\`\`
 
-The main client class (\`${SDK}\`, under \`Sources/ProjectNameSDK/core\`)
+The main client class (\`${SDK}\`, under \`Sources/${swiftTargetDir(model)}/core\`)
 exposes the entity accessors. Reference entity or utility types directly only
 when needed. The SDK is dependency-free: JSON parsing is the vendored
 \`Struct/JSON.swift\`, HTTP transport is Foundation's \`URLSession\`, and the

package/project/.sdk/src/cmp/swift/Test_swift.ts

@@ -3,6 +3,8 @@ import type {
   ModelEntity
 } from '@voxgig/apidef'
 
+import { swiftTargetDir, swiftTestDir } from './utility_swift'
+
 import { cmp, each, Folder, entityCollection } from '@voxgig/sdkgen'
 
 
@@ -20,7 +22,7 @@ const Test = cmp(function Test(props: any) {
   // templates in tm/swift/Tests. Only the API-specific entity/direct tests
   // are generated here.
   Folder({ name: 'Tests' }, () => {
-    Folder({ name: 'ProjectNameSDKTests' }, () => {
+    Folder({ name: swiftTestDir(model) }, () => {
       const entity = each(entityCollection(model))
         .filter((e: any) => false !== e.active)
 

package/project/.sdk/src/cmp/swift/utility_swift.ts

@@ -132,10 +132,26 @@ function clean(o: any, dropDefaults?: boolean): any {
 }
 
 
+// SwiftPM's convention is Sources/<target>/ and Tests/<target>Tests/, and the
+// target is named <Name>Sdk in Package_swift. These name the two directories
+// so the copied runtime lands under the API's own name rather than under the
+// template's placeholder — see the note in Main_swift.
+function swiftTargetDir(model: any): string {
+  return model.const.Name + 'Sdk'
+}
+
+
+function swiftTestDir(model: any): string {
+  return swiftTargetDir(model) + 'Tests'
+}
+
+
 export {
   clean,
   projectPath,
   swiftPascalName,
+  swiftTargetDir,
+  swiftTestDir,
   swiftVarName,
   swiftString,
 }

package/project/.sdk/src/cmp/ts/Config_ts.ts

@@ -142,8 +142,11 @@ const Config = cmp(async function Config(props: any) {
           Line(` ${f.name}: ${nom(f, 'Name')}Feature,`)
         }),
 
+        // Rendered from configDefinition's def, not from f.config, so the
+        // literal carries the feature's `transport` role (station design
+        // §8.4) beside its options and cannot drift from the data rep.
         '// #FeatureConfigs': () => each(feature, (f: any) => {
-          Line(` ${f.name}: ${formatJson(f.config, { margin: 4 })},`)
+          Line(` ${f.name}: ${formatJson(configDef.feature[f.name], { margin: 4 })},`)
         }),
 
 

package/project/.sdk/src/cmp/ts/Main_ts.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
-  entityClassName, entityCollection, srcFeatureExcludes,
+  entityClassName, entityCollection, srcFeatureExcludes, stationLibrary,
 } from '@voxgig/sdkgen'
 
 
@@ -106,6 +106,25 @@ if (fres instanceof Promise) { await fres }
             MainEntity(entprops)
           })
         })
+
+      // Station self-registration (station design §6.2 path 1;
+      // station-declarative-config §11 item 2): emitted ONLY when the model
+      // carries an ACTIVE station feature (installed via
+      // `package add @voxgig/sdkgen-station`). The library package name
+      // comes from the feature model's own `deps.ts` block — the same entry
+      // collectDeps flows into package.json — so the manifest dependency
+      // and the emitted require cannot disagree.
+      const stationPkg = stationLibrary(model, target.name)
+      if (null != stationPkg) {
+        Fragment({
+          from: Path.normalize(
+            __dirname + '/../../../src/cmp/ts/fragment/MainStation.fragment.ts'),
+          replace: {
+            ...props.ctx$.stdrep,
+            "'STATIONPKG'": JSON.stringify(stationPkg),
+          }
+        })
+      }
     })
 
     Config({ target })

package/project/.sdk/src/cmp/ts/fragment/MainStation.fragment.ts

@@ -0,0 +1,36 @@
+
+
+// Station self-registration (voxgig/station design §6.2, path 1): linking
+// this package is the whole bootstrap. When the station library is
+// installed beside this SDK, the {construct, config} factory pair is
+// registered under the api slug (config.main.slug, the descriptor slug) at
+// module init, so `station.sdk('<name>')` needs no imports in application
+// code. Registration is SOFT — the station library is a peer dependency of
+// the station feature, and a project without it skips registration and
+// gets exactly the SDK it always had. Only a genuine module-not-found is
+// swallowed: a station that RESOLVES but throws while loading must
+// propagate (a silently empty factory table has no visible cause), and so
+// must station_factory_conflict — two different builds of one SDK in one
+// process is not a thing to pick between quietly.
+let stationInstalled = true
+try { require.resolve('STATIONPKG') }
+catch (err: any) {
+  // MODULE_NOT_FOUND is the absent case. Anything else - an invalid
+  // package config, a root entry the package does not export - is a
+  // real failure to load a station that IS installed, and swallowing
+  // it would leave an empty factory table with no visible cause.
+  if ('MODULE_NOT_FOUND' !== err?.code) { throw err }
+  stationInstalled = false
+}
+
+if (stationInstalled) {
+  const { provide } = require('STATIONPKG')
+  // A station library predating the factory table has no provide() —
+  // there is nothing to register with, which is not this SDK's error.
+  if ('function' === typeof provide) {
+    provide(config.main.slug, {
+      construct: (options?: any) => new ProjectNameSDK(options),
+      config,
+    })
+  }
+}

package/project/.sdk/src/cmp/zig/Config_zig.ts

@@ -38,8 +38,10 @@ const Config = cmp(async function Config(props: any) {
   // representations render from the same `def`, so they cannot describe
   // different configs - and this target picks up `options.server` (the
   // OpenAPI server-variable defaults), which the hand-rolled build here
-  // omitted entirely.
-  const { def: config, json: configJson } = configDefinition(model)
+  // omitted entirely. Passing target.name opts this target into the main
+  // slug/version/target identity fields (read by station's descriptor -
+  // see configDefinition).
+  const { def: config, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
   File({ name: 'config.' + target.ext }, () => {

package/project/.sdk/tm/elixir/lib/utility/struct/voxgig_struct.ex

@@ -26,17 +26,74 @@ defmodule Voxgig.Struct do
   # ---------------------------------------------------------------------------
 
   @heap :vox_struct_heap
-
+  @heap_owner :vox_struct_heap_owner
+
+  # A named ETS table is owned by the process that created it and dies with
+  # that process. The values here are HANDLES into it - {:vmap, id} - and they
+  # are passed across process boundaries freely: ExUnit runs every test in its
+  # own process, and a generated SDK caches its config in :persistent_term,
+  # which outlives all of them. So the table has to outlive its creator, or a
+  # handle that is still very much alive resolves into a fresh empty table.
+  #
+  # Adding ensure_heap to hget stopped that raising ArgumentError, but a silent
+  # nil turned out to be worse than the raise: the generated config's staleness
+  # check (`usable?`) was written to read the raise as "rebuild me", so once the
+  # raise stopped, a dead handle was cached as good and clone/1 crashed further
+  # down with "Enumerable not implemented for nil of type Atom" - nothing in the
+  # message pointing at the heap.
+  #
+  # The table is therefore owned by a dedicated process that never exits, and
+  # every id stays valid for the life of the VM.
   defp ensure_heap do
     case :ets.whereis(@heap) do
-      :undefined ->
+      :undefined -> start_heap()
+      _ -> :ok
+    end
+  end
+
+  defp start_heap do
+    caller = self()
+
+    spawn(fn ->
+      owner =
         try do
-          :ets.new(@heap, [:set, :public, :named_table])
+          Process.register(self(), @heap_owner)
+          true
         rescue
-          ArgumentError -> :ok
+          ArgumentError -> false
         end
 
-        :ok
+      if owner do
+        case :ets.whereis(@heap) do
+          :undefined -> :ets.new(@heap, [:set, :public, :named_table])
+          _ -> :ok
+        end
+      end
+
+      send(caller, :vox_heap_ready)
+
+      # Hold the table for the life of the VM. This process does nothing else.
+      if owner, do: Process.sleep(:infinity)
+    end)
+
+    receive do
+      :vox_heap_ready -> :ok
+    after
+      5_000 -> :ok
+    end
+
+    await_heap(1_000)
+  end
+
+  # The loser of a registration race reports ready before the winner has
+  # necessarily reached :ets.new, so wait on the table, not on the message.
+  defp await_heap(0), do: :ok
+
+  defp await_heap(n) do
+    case :ets.whereis(@heap) do
+      :undefined ->
+        Process.sleep(1)
+        await_heap(n - 1)
 
       _ ->
         :ok
@@ -50,13 +107,10 @@ defmodule Voxgig.Struct do
     id
   end
 
-  # ensure_heap here too, not only in alloc. A named ETS table belongs to the
-  # process that created it and dies with it — and ExUnit runs each test in its
-  # own process, so a table created by an alloc in one test is gone by the
-  # next. hget then raised ArgumentError ("the table identifier does not refer
-  # to an existing ETS table") from whichever unrelated test happened to run
-  # second, which is why this surfaced as a pipeline/netsim failure rather than
-  # as anything to do with the heap.
+  # ensure_heap here too, not only in alloc, so a read can never hit a missing
+  # table. With a permanent owner (above) that should not arise; before there
+  # was one, it raised ArgumentError from whichever unrelated test happened to
+  # run second.
   defp hget(id) do
     ensure_heap()
 

package/project/.sdk/tm/zig/Makefile

@@ -8,10 +8,30 @@ build:
 # tests pass, due to *MapRef/*ListRef cross-references in arena teardown. We
 # filter the output: if "N/N tests passed" with N==total, treat as success.
 # `--summary all` is required so the count is printed.
+#
+# A TEST THAT DID NOT COMPILE IS NOT IN THE TALLY. The tolerance above is for a
+# crash AFTER the tests ran, and it must never cover a build that failed: a
+# compile error means those test binaries never ran, so they never reach
+# "total", and "60/66 passed; 6 skipped" reads as a clean 66/66 while five of
+# thirteen build steps are red. That is exactly how a `.undef` tag that does
+# not exist in JsonValue shipped in 4.2.2 and stayed green in every sweep
+# afterwards. So: if any build step failed, this target fails, whatever the
+# test counts say.
 test:
 	@out=$$(zig build test --summary all 2>&1); code=$$?; \
 	echo "$$out"; \
 	if [ $$code -eq 0 ]; then exit 0; fi; \
+	steps=$$(echo "$$out" | grep -oE '[0-9]+/[0-9]+ steps succeeded' | tail -1); \
+	sdone=$$(echo "$$steps" | sed -E 's#([0-9]+)/([0-9]+).*#\1#'); \
+	stotal=$$(echo "$$steps" | sed -E 's#([0-9]+)/([0-9]+).*#\2#'); \
+	if [ -n "$$steps" ] && [ "$$sdone" != "$$stotal" ]; then \
+		echo "zig: $$steps — a build step failed, so the test tally is incomplete"; \
+		exit 1; \
+	fi; \
+	if echo "$$out" | grep -q 'error: the following command failed with .* compilation errors'; then \
+		echo "zig: compilation errors — not a teardown crash"; \
+		exit 1; \
+	fi; \
 	summary=$$(echo "$$out" | grep -oE '[0-9]+/[0-9]+ tests passed(; [0-9]+ skipped)?' | tail -1); \
 	passed=$$(echo "$$summary" | sed -E 's#([0-9]+)/([0-9]+).*#\1#'); \
 	total=$$(echo "$$summary" | sed -E 's#([0-9]+)/([0-9]+).*#\2#'); \

package/project/.sdk/tm/zig/feature/test.zig

@@ -105,7 +105,7 @@ fn fixIds(_: Allocator, key: ?[]const u8, val: Value, _: Value, path: []const []
 // while the fixture plainly held two. Mirrors the go/ts/lua/php mocks, which
 // already wrap; rust, c and zig were the three that did not.
 fn envelope(ctx: *Context, data: Value) Value {
-    if (data == .undef or data == .null) return data;
+    if (data == .null) return data;
     const restf = h.getpath(&.{ "transform", "res" }, ctx.point);
     if (restf != .string) return data;
     const spec = restf.string;

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "4.2.3",
+  "version": "4.2.5",
   "provides": {
     "target": [
       "c",