@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/js/test/omni.test.js

@@ -0,0 +1,105 @@
+// Smoke tests for the vendored omni runner itself: a runner that cannot
+// FAIL a bad entry would turn every corpus suite vacuously green, so pin
+// the failure paths, not just the happy one.
+
+const { test, describe } = require('node:test')
+const assert = require('node:assert')
+
+const { SDK } = require('..')
+
+const { OmniError, makeRunner } = require('./omni')
+
+
+// A minimal in-memory spec: no fixture file, no OMNI block (lenient v0,
+// like the shared corpus).
+const SPEC = {
+  primary: {
+    smoke: {
+      basic: {
+        set: [
+          { in: 1, out: 2 },
+          { in: 41, out: 42 },
+        ],
+      },
+      bad: {
+        set: [
+          { in: 1, out: 999 },
+        ],
+      },
+      err: {
+        set: [
+          { in: 0, err: 'zero refused' },
+        ],
+      },
+    },
+  },
+}
+
+const inc = (n) => {
+  if (0 === n) {
+    throw new Error('smoke: zero refused')
+  }
+  return n + 1
+}
+
+
+describe('omni', () => {
+
+  test('runset passes a correct subject', async () => {
+    const runner = await makeRunner(SPEC, SDK.test())
+    const R = await runner('smoke')
+    await R.runset(R.spec.basic, inc)
+  })
+
+
+  test('runset FAILS a wrong result, with OmniError', async () => {
+    const runner = await makeRunner(SPEC, SDK.test())
+    const R = await runner('smoke')
+    await assert.rejects(
+      () => R.runset(R.spec.bad, inc),
+      (err) => {
+        assert.equal(err.name, 'OmniError')
+        assert.ok(err instanceof OmniError)
+        assert.match(err.message, /result mismatch/)
+        return true
+      })
+  })
+
+
+  test('an expected error is matched, an unexpected one fails', async () => {
+    const runner = await makeRunner(SPEC, SDK.test())
+    const R = await runner('smoke')
+
+    await R.runset(R.spec.err, inc)
+
+    await assert.rejects(
+      () => R.runset(R.spec.err, (n) => n),
+      (err) => {
+        assert.equal(err.name, 'OmniError')
+        assert.match(err.message, /expected error did not occur/)
+        return true
+      })
+  })
+
+
+  // js-resolver specific: the corpus throws error-shaped plain maps
+  // (generated makeError rethrows the fixture's err verbatim), and the
+  // vendored js omni port would read them as '[object Object]' (the
+  // omni#54 errify fix is TypeScript-only at this tag). The resolver
+  // rethrows them as real Errors — pin that, both matching and failing.
+  test('a map-shaped throwable is matched by its message', async () => {
+    const runner = await makeRunner(SPEC, SDK.test())
+    const R = await runner('smoke')
+
+    await R.runset(R.spec.err, () => { throw { message: 'zero refused' } })
+
+    await assert.rejects(
+      () => R.runset(R.spec.err, () => { throw { message: 'some other error' } }),
+      (err) => {
+        assert.equal(err.name, 'OmniError')
+        assert.match(err.message, /error mismatch/)
+        return true
+      })
+  })
+
+})

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

@@ -5,7 +5,7 @@ const assert = require('node:assert')
 
 const {
   makeRunner,
-} = require('../runner')
+} = require('../omni')
 
 const {
   SDK,
@@ -38,7 +38,11 @@ describe('PrimaryUtility', async () => {
     spec = run.spec
     runset = run.runset
     runsetflags = run.runsetflags
-    client = run.client
+    // Under the old hand-vendored runner, run.client WAS the SDK; under
+    // omni it is the provider wrapping it. This suite treats the client as
+    // the SDK — including ASSIGNING to client._features, which prototype
+    // delegation cannot forward — so unwrap the real instance.
+    client = run.client.sdk
     utility = client.utility()
     struct = utility.struct
   })

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

@@ -1,4 +1,4 @@
-// VERSION: @voxgig/struct 0.0.10
+// VERSION: @voxgig/struct-js 0.1.4 (vendored via omni; see ../omni.js)
 // RUN: npm test
 // RUN-SOME: npm run test-some --pattern=getpath
 
@@ -9,7 +9,7 @@ const {
   makeRunner,
   nullModifier,
   NULLMARK,
-} = require('../runner')
+} = require('../omni')
 
 
 const {
@@ -260,6 +260,31 @@ describe('struct', async () => {
   })
 
 
+  // The struct.nullsem section: does a PRESENT key holding a JSON null
+  // read as "no value"? Opt-in per target (create-sdkgen ships it; an
+  // older project corpus may predate it - the skip below says so OUT
+  // LOUD rather than passing vacuously). All lanes run {null: false}.
+  test('nullsem', async (t) => {
+    const nullsem = spec.nullsem
+    if (null == nullsem) {
+      t.skip('corpus predates struct.nullsem - refresh .sdk/test/struct from create-sdkgen')
+      return
+    }
+    const { getprop, getelem, getpath, haskey, keysof } = struct
+
+    await runsetflags(nullsem.getprop, { null: false }, (vin) =>
+      undefined === vin.alt ? getprop(vin.val, vin.key) : getprop(vin.val, vin.key, vin.alt))
+    await runsetflags(nullsem.getelem, { null: false }, (vin) =>
+      undefined === vin.alt ? getelem(vin.val, vin.key) : getelem(vin.val, vin.key, vin.alt))
+    await runsetflags(nullsem.getpath, { null: false }, (vin) =>
+      undefined === vin.alt ? getpath(vin.store, vin.path) : getpath(vin.store, vin.path, vin.alt))
+    await runsetflags(nullsem.haskey, { null: false }, (vin) =>
+      haskey(vin.src, vin.key))
+    await runsetflags(nullsem.keysof, { null: false }, (vin) =>
+      keysof(vin))
+  })
+
+
   test('minor-edge-getprop', async () => {
     const { getprop } = struct
 

package/project/.sdk/tm/js/test/vendor/omni/index.js

@@ -0,0 +1,77 @@
+// VENDORED: @voxgig/omni 0.1.4 (javascript/src/index.js)
+// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260907-0029-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+// @voxgig/omni-js - shared multi-language test runner.
+//
+// The names are destructured into local bindings and re-exported in
+// shorthand, rather than spread. Node's cjs-module-lexer can only detect
+// names it can read STATICALLY: `module.exports = {...runner, ...util}` is
+// opaque to it, so `import { makeRunner } from '@voxgig/omni-js'` failed
+// with "Named export 'makeRunner' not found", while the same import from
+// @voxgig/omni worked because tsc emits an explicit
+// `Object.defineProperty(exports, ...)` per name. Publishing is what made
+// that asymmetry reachable.
+//
+// Shorthand specifically: `{ makeRunner: runner.makeRunner }` is a member
+// expression and the lexer cannot follow it either - that form was tried
+// and `make pack-check` rejected it.
+//
+// This also mirrors canonical: typescript/src/index.ts lists exactly these
+// names, and the parity tool reads that list.
+
+const {
+  CAPABILITIES,
+  EXISTSMARK,
+  NULLMARK,
+  OmniError,
+  SPECVERSION,
+  UNDEFMARK,
+  errify,
+  fixjson,
+  loadspec,
+  makeRunner,
+  match,
+  matchval,
+  nullmodifier,
+  resolvespec,
+} = require('./runner')
+
+const {
+  clone,
+  deepequal,
+  getpath,
+  islist,
+  ismap,
+  isnode,
+  jsonstr,
+  pathify,
+  stringify,
+  walk,
+} = require('./util')
+
+module.exports = {
+  CAPABILITIES,
+  EXISTSMARK,
+  NULLMARK,
+  OmniError,
+  SPECVERSION,
+  UNDEFMARK,
+  errify,
+  fixjson,
+  loadspec,
+  makeRunner,
+  match,
+  matchval,
+  nullmodifier,
+  resolvespec,
+  clone,
+  deepequal,
+  getpath,
+  islist,
+  ismap,
+  isnode,
+  jsonstr,
+  pathify,
+  stringify,
+  walk,
+}