@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/java/test/vendor/omni/Util.java

@@ -0,0 +1,322 @@
+// VENDORED: @voxgig/omni sdk-20260904-1610-0 (java/src/com/voxgig/omni/Util.java)
+// Source: https://github.com/voxgig/omni @ 8c3e1b573a8d35796f7fc45e3226b977023cabf7  [tag: sdk-20260904-1610-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+// Omni internal JSON utilities.
+//
+// Self-contained by design: the omni runner must be able to test *any*
+// library, including libraries that provide these same operations.
+
+package com.voxgig.omni;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public final class Util {
+
+  public static final String NULLMARK = "__NULL__"; // Value is JSON null.
+  public static final String UNDEFMARK = "__UNDEF__"; // Value is not present.
+  public static final String EXISTSMARK = "__EXISTS__"; // Value exists.
+
+  private Util() {}
+
+  /** A map (JSON object)? */
+  public static boolean ismap(Object val) {
+    return val instanceof Map;
+  }
+
+  /** A list (JSON array)? */
+  public static boolean islist(Object val) {
+    return val instanceof List;
+  }
+
+  /** A container (map or list)? */
+  public static boolean isnode(Object val) {
+    return ismap(val) || islist(val);
+  }
+
+  /** A JSON number? Booleans are not numbers. */
+  public static boolean isnum(Object val) {
+    return val instanceof Number;
+  }
+
+  /** Absent (no value at all)? */
+  public static boolean isabsent(Object val) {
+    return val instanceof Json.Absent;
+  }
+
+  /** Deep copy a JSON value. Other values pass through by reference. */
+  @SuppressWarnings("unchecked")
+  public static Object clone(Object val) {
+    if (islist(val)) {
+      List<Object> out = new ArrayList<>();
+      for (Object entry : (List<Object>) val) {
+        out.add(clone(entry));
+      }
+      return out;
+    }
+
+    if (ismap(val)) {
+      Map<String, Object> out = new LinkedHashMap<>();
+      for (Map.Entry<String, Object> entry : ((Map<String, Object>) val).entrySet()) {
+        out.put(entry.getKey(), clone(entry.getValue()));
+      }
+      return out;
+    }
+
+    return val;
+  }
+
+  /** Read a value by path. Returns ABSENT when any step is missing. */
+  @SuppressWarnings("unchecked")
+  public static Object getpath(Object val, List<Object> path) {
+    Object current = val;
+
+    for (Object part : path) {
+      if (islist(current)) {
+        List<Object> list = (List<Object>) current;
+        int index;
+        try {
+          index = isnum(part) ? ((Number) part).intValue() : Integer.parseInt(String.valueOf(part));
+        } catch (NumberFormatException err) {
+          return Json.ABSENT;
+        }
+        if (index < 0 || index >= list.size()) {
+          return Json.ABSENT;
+        }
+        current = list.get(index);
+        continue;
+      }
+
+      if (ismap(current)) {
+        Map<String, Object> map = (Map<String, Object>) current;
+        String key = strkey(part);
+        if (!map.containsKey(key)) {
+          return Json.ABSENT;
+        }
+        current = map.get(key);
+        continue;
+      }
+
+      return Json.ABSENT;
+    }
+
+    return current;
+  }
+
+  /** Render a path part as a map key. */
+  public static String strkey(Object part) {
+    if (part instanceof String) {
+      return (String) part;
+    }
+    if (isnum(part)) {
+      return numstr(((Number) part).doubleValue());
+    }
+    return String.valueOf(part);
+  }
+
+  /** The callback of a walk. */
+  public interface Apply {
+    Object apply(Object key, Object val, Object parent, List<Object> path);
+  }
+
+  /** Depth-first walk: children first, then the containing node. */
+  public static Object walk(Object val, Apply apply) {
+    return walkdown(val, apply, null, null, new ArrayList<>());
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Object walkdown(
+      Object val, Apply apply, Object key, Object parent, List<Object> path) {
+
+    if (islist(val)) {
+      List<Object> list = (List<Object>) val;
+      for (int index = 0; index < list.size(); index++) {
+        List<Object> childpath = new ArrayList<>(path);
+        childpath.add(index);
+        list.set(index, walkdown(list.get(index), apply, index, list, childpath));
+      }
+    } else if (ismap(val)) {
+      Map<String, Object> map = (Map<String, Object>) val;
+      for (String childkey : new ArrayList<>(map.keySet())) {
+        List<Object> childpath = new ArrayList<>(path);
+        childpath.add(childkey);
+        map.put(childkey, walkdown(map.get(childkey), apply, childkey, map, childpath));
+      }
+    }
+
+    return apply.apply(key, val, parent, path);
+  }
+
+  /** Deep structural equality: numbers by value, bools never numbers. */
+  @SuppressWarnings("unchecked")
+  public static boolean deepequal(Object a, Object b) {
+    if (a == b) {
+      return true;
+    }
+
+    if (a instanceof Boolean || b instanceof Boolean) {
+      return a instanceof Boolean && b instanceof Boolean && a.equals(b);
+    }
+
+    if (isnum(a) || isnum(b)) {
+      if (!isnum(a) || !isnum(b)) {
+        return false;
+      }
+      double anum = ((Number) a).doubleValue();
+      double bnum = ((Number) b).doubleValue();
+      return anum == bnum || (Double.isNaN(anum) && Double.isNaN(bnum));
+    }
+
+    if (isabsent(a) || isabsent(b)) {
+      return isabsent(a) && isabsent(b);
+    }
+
+    if (null == a || null == b) {
+      return null == a && null == b;
+    }
+
+    if (islist(a) || islist(b)) {
+      if (!islist(a) || !islist(b)) {
+        return false;
+      }
+      List<Object> alist = (List<Object>) a;
+      List<Object> blist = (List<Object>) b;
+      if (alist.size() != blist.size()) {
+        return false;
+      }
+      for (int index = 0; index < alist.size(); index++) {
+        if (!deepequal(alist.get(index), blist.get(index))) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    if (ismap(a) || ismap(b)) {
+      if (!ismap(a) || !ismap(b)) {
+        return false;
+      }
+      Map<String, Object> amap = (Map<String, Object>) a;
+      Map<String, Object> bmap = (Map<String, Object>) b;
+      if (amap.size() != bmap.size()) {
+        return false;
+      }
+      for (Map.Entry<String, Object> entry : amap.entrySet()) {
+        if (!bmap.containsKey(entry.getKey())) {
+          return false;
+        }
+        if (!deepequal(entry.getValue(), bmap.get(entry.getKey()))) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    return a.equals(b);
+  }
+
+  /** Render a number the same way in every port: 5.0 prints as 5. */
+  public static String numstr(double val) {
+    if (Double.isNaN(val) || Double.isInfinite(val)) {
+      return "null";
+    }
+    if (val == Math.rint(val) && Math.abs(val) < 9007199254740992.0) {
+      return Long.toString((long) val);
+    }
+    String out = Double.toString(val);
+    return out;
+  }
+
+  /** Render a string as a JSON string literal. */
+  public static String quote(String val) {
+    StringBuilder out = new StringBuilder("\"");
+    for (int index = 0; index < val.length(); index++) {
+      char c = val.charAt(index);
+      switch (c) {
+        case '"':
+          out.append("\\\"");
+          break;
+        case '\\':
+          out.append("\\\\");
+          break;
+        case '\n':
+          out.append("\\n");
+          break;
+        case '\r':
+          out.append("\\r");
+          break;
+        case '\t':
+          out.append("\\t");
+          break;
+        default:
+          if (c < 0x20) {
+            out.append(String.format("\\u%04x", (int) c));
+          } else {
+            out.append(c);
+          }
+      }
+    }
+    return out.append('"').toString();
+  }
+
+  /** Compact JSON text with map keys sorted, identical in every port. */
+  @SuppressWarnings("unchecked")
+  public static String jsonstr(Object val) {
+    if (isabsent(val)) {
+      return "undefined";
+    }
+
+    if (null == val) {
+      return "null";
+    }
+
+    if (val instanceof Boolean) {
+      return ((Boolean) val) ? "true" : "false";
+    }
+
+    if (val instanceof String) {
+      return quote((String) val);
+    }
+
+    if (isnum(val)) {
+      return numstr(((Number) val).doubleValue());
+    }
+
+    if (islist(val)) {
+      List<String> parts = new ArrayList<>();
+      for (Object entry : (List<Object>) val) {
+        parts.add(jsonstr(entry));
+      }
+      return "[" + String.join(",", parts) + "]";
+    }
+
+    if (ismap(val)) {
+      Map<String, Object> sorted = new TreeMap<>((Map<String, Object>) val);
+      List<String> parts = new ArrayList<>();
+      for (Map.Entry<String, Object> entry : sorted.entrySet()) {
+        parts.add(quote(entry.getKey()) + ":" + jsonstr(entry.getValue()));
+      }
+      return "{" + String.join(",", parts) + "}";
+    }
+
+    return quote(String.valueOf(val));
+  }
+
+  /** Strings verbatim, everything else as compact JSON. */
+  public static String stringify(Object val) {
+    return val instanceof String ? (String) val : jsonstr(val);
+  }
+
+  /** Render a path as a dotted string. */
+  public static String pathify(List<Object> path) {
+    List<String> parts = new ArrayList<>();
+    for (Object entry : (null == path ? Arrays.asList() : path)) {
+      parts.add(strkey(entry));
+    }
+    return String.join(".", parts);
+  }
+}

package/project/.sdk/tm/java/utility/MakeSpec.java

@@ -45,7 +45,9 @@ final class MakeSpec {
 
     Object allowMethodRaw = Struct.getpath(options, List.of("allow", "method"));
     String allowMethod = allowMethodRaw instanceof String ? (String) allowMethodRaw : "";
-    if (!allowMethod.contains(ctx.spec.method)) {
+    // null-safe: an op outside the convention resolves NO method (see
+    // PrepareMethod), which the allow list can never contain.
+    if (null == ctx.spec.method || !allowMethod.contains(ctx.spec.method)) {
       throw ctx.makeError("spec_method_allow",
           "Method \"" + ctx.spec.method
               + "\" not allowed by SDK option allow.method value: \"" + allowMethod + "\"");

package/project/.sdk/tm/java/utility/PrepareMethod.java

@@ -28,10 +28,10 @@ final class PrepareMethod {
       return ((String) pm).toUpperCase();
     }
 
-    String m = METHOD_MAP.get(opname);
-    if (m != null) {
-      return m;
-    }
-    return "GET";
+    // No default: an op name outside the convention resolves to NO method,
+    // exactly as the ts reference (`methodMap[key]` is undefined there).
+    // The silent-pass engine hid a stray "GET" fallback here; the shared
+    // corpus (prepareMethod, opname "bad" -> null) pins it now.
+    return METHOD_MAP.get(opname);
   }
 }

package/project/.sdk/tm/java/utility/struct/Struct.java

@@ -1,5 +1,6 @@
-// Vendored from github.com/voxgig/struct java/src/Struct.java — do not edit here;
-// upstream is the voxgig struct java port. Package adjusted for the ProjectName SDK.
+// VENDORED: @voxgig/struct 0.1.1 (java/src/Struct.java)
+// Source: https://github.com/voxgig/struct @ 2caf7f448f265144c18dd6fab6ba270a7f3bca07  [tag: sdk-20260904-1610-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 package JAVAPACKAGE.utility.struct;
 
 
@@ -2636,9 +2637,21 @@ public class Struct {
             setprop(pl, i, clone(childtm));
           }
           while (pl.size() > dpl.size()) pl.remove(pl.size() - 1);
-          inj.keyI = 0;
 
-          return getprop(inj.dparent, 0);
+          // NOTE: modifying inj! This extends the child value loop in inject
+          // to cover every cloned child.
+          for (int ckeyI = size(inj.keys); ckeyI < size(pl); ckeyI++) {
+            inj.keys.add(strkey(ckeyI));
+          }
+
+          // Restart the child value loop at the first element (the loop
+          // increments keyI on resume) so that the first element is also
+          // validated against the child template.
+          inj.keyI = -1;
+
+          // SKIP leaves the cloned child template in place at the first
+          // element so the resumed loop can validate it.
+          return SKIP;
         }
 
         return UNDEF;

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

@@ -1,8 +1,8 @@
-// VENDORED: @voxgig/struct 0.3.2 (javascript/src/struct.js)
-// Source: https://github.com/voxgig/struct @ 94409354d0a60fda8098c83e290583b7dee76c84
+// VENDORED: @voxgig/struct 0.1.4 (javascript/src/struct.js)
+// Source: https://github.com/voxgig/struct @ 2caf7f448f265144c18dd6fab6ba270a7f3bca07  [tag: sdk-20260904-1610-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 /* Copyright (c) 2025-2026 Voxgig Ltd. MIT LICENSE. */
-// VERSION: @voxgig/struct 0.3.2
+// VERSION: @voxgig/struct-js 0.1.4
 /* Voxgig Struct
  * =============
  *

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

@@ -0,0 +1,251 @@
+// The corpus test runner: vendored @voxgig/omni driven through its NATIVE
+// API (`makeRunner(specref, provider)`), presented to the corpus tests in
+// the struct-runner shape they already use (`R.spec`, `R.runset`,
+// `R.runsetflags`, `R.client`). No compat shim is vendored: the adapter
+// below IS the whole bridge, per language, per the vendor-tag rollout
+// (docs/design/vendor-tag-rollout.md, Decision 4).
+//
+// Two local decisions, both required (mirroring tm/ts/test/omni.ts):
+//
+// 1. SPEC PATH. omni's own spec resolution expects the caller to hand it a
+//    usable path — its docs say a port must resolve the path itself. This
+//    module lives at test/omni.js, the same depth as the old
+//    test/runner.js, so the existing TEST_JSON_FILE constant keeps working
+//    verbatim: a relative path is absolutized against __dirname.
+//
+// 2. PROVIDER DELEGATION. Corpus-driven contexts get `ctx.client` set to
+//    the runner's provider (omni overwrites it on any ctx/args map entry).
+//    A five-hook provider object HIDES the live SDK from the generated
+//    utilities that reach through it — prepareHeaders via client.options(),
+//    fetcher via client._mode, the feature helpers via client._rootctx and
+//    even ASSIGNING client._features. So the provider here is built by
+//    PROTOTYPE DELEGATION over the live SDK instance: every SDK member
+//    resolves, while the omni hooks sit on top. (Upstream omni#56 tracks
+//    giving the stock provider the same shape.)
+//
+// ZERO-ARGUMENT ENTRIES, checked and deliberately NOT corrected here: six
+// of omni's eight upstream compat shims rewrite entries with no in/args/ctx
+// to a true zero-argument call. The javascript shim carries no such
+// correction, because JavaScript cannot tell `subject(undefined)` from
+// `subject()` (default parameters fire either way), and omni's native rule
+// (`args = [clone(entry.in)]`) is byte-identical to what the retired
+// tm/js/test/runner.js already did. There is nothing to port, and the
+// shared corpus keeps asserting exactly what it asserted before the swap.
+//
+// THE VENDORED JS PORT LACKS THE omni#54 RUNNER FIXES the TypeScript port
+// has at this tag (upstream omni#57 tracks porting them). Vendored files
+// are resynced, never edited, so each gap is worked around HERE instead:
+//
+// a. `errify`/`errmessage` collapse non-Error throwables to `String(err)`
+//    = '[object Object]'. The shared corpus throws error-shaped plain maps
+//    (generated makeError rethrows the fixture's err verbatim), which the
+//    retired runner matched by `.message` regardless of class. Every
+//    subject is therefore wrapped (`wrapsubject`) to rethrow such a map as
+//    a real Error carrying the map's own properties — errmessage() then
+//    reads the right message, and the native errify's spread preserves the
+//    map's fields for `match.err`.
+//
+// b. `match()` clones its base, and the vendored clone() has no cycle
+//    guard, so any ctx-carrying `match` entry — the corpus has fourteen —
+//    would blow the stack. The live cycles reach the match base on three
+//    edges, every one of them runner/SDK bookkeeping the corpus never
+//    asserts on, so the resolver makes exactly those NON-ENUMERABLE —
+//    invisible to clone()/fixjson()'s Object.keys() walks while every
+//    property READ still works:
+//      - `ctx.client` (assigned by the runner after contextify): the
+//        provider, whose `sdk._rootctx.client` reaches the SDK again;
+//      - the provider's own `sdk`: same cycle, one hop earlier;
+//      - `err.ctx` on Error objects a subject returns or throws:
+//        generated `ctx.error()` attaches the LIVE context to every error
+//        it makes, so `ctx.result.err.ctx === ctx` — a cycle entirely
+//        inside the entry's own result (`sanitizeerrs`, applied at the
+//        subject boundary by `wrapsubject`).
+//    This also keeps the unguarded jsonstr() away from cyclic values:
+//    failure messages only ever render acyclic data.
+
+const { isAbsolute, join } = require('node:path')
+
+const {
+  EXISTSMARK,
+  NULLMARK,
+  UNDEFMARK,
+  OmniError,
+  nullmodifier,
+  makeRunner: omnimakerunner,
+} = require('./vendor/omni/index')
+
+
+// Keep a property readable and writable but invisible to Object.keys(),
+// which is how the vendored clone()/fixjson() walk. A later plain
+// assignment (the runner does `ctx.client = provider`) updates the value
+// and keeps the non-enumerability.
+function hideprop(obj, key) {
+  Object.defineProperty(obj, key, {
+    value: obj[key],
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  })
+}
+
+
+// Workaround (a): rethrow an error-shaped plain map as a real Error so the
+// vendored errmessage() reads `.message` instead of '[object Object]'. The
+// map's own properties ride along for the native errify's spread. Real
+// Errors and everything else pass through untouched.
+function normthrown(err) {
+  if (err instanceof Error) {
+    return err
+  }
+  if (null != err && 'object' === typeof err && 'string' === typeof err.message) {
+    return Object.assign(new Error(err.message), err)
+  }
+  return err
+}
+
+// Workaround (b), third edge: generated `ctx.error()` attaches the live
+// Context to the errors it makes (`err.ctx`), so a returned result or a
+// thrown error can carry a cycle entirely inside itself
+// (ctx.result.err.ctx === ctx). Walk a subject's outcome and hide that
+// bookkeeping on every Error found; the corpus never asserts on `err.ctx`.
+function sanitizeerrs(val, seen) {
+  if (null == val || 'object' !== typeof val) {
+    return val
+  }
+
+  seen = seen || new Set()
+  if (seen.has(val)) {
+    return val
+  }
+  seen.add(val)
+
+  if (val instanceof Error && Object.prototype.propertyIsEnumerable.call(val, 'ctx')) {
+    hideprop(val, 'ctx')
+  }
+
+  for (const key of Object.keys(val)) {
+    sanitizeerrs(val[key], seen)
+  }
+
+  return val
+}
+
+function wrapsubject(subject) {
+  if ('function' !== typeof subject) {
+    return subject
+  }
+  return async function (...args) {
+    try {
+      return sanitizeerrs(await subject.apply(this, args))
+    }
+    catch (err) {
+      throw sanitizeerrs(normthrown(err))
+    }
+  }
+}
+
+
+// The omni hooks for an SDK subject — what the retired compat shim called
+// `structprovider`, inlined here because this resolver is the one consumer.
+function sdkhooks(sdk) {
+  return {
+    // A subject is resolved from the utility, or from utility.struct.
+    subject: (name) => {
+      const utility = sdk.utility()
+      return wrapsubject(utility[name] || (utility.struct && utility.struct[name]))
+    },
+
+    // A DEF.client entry becomes another SDK instance — rewrapped with the
+    // same delegating shape, not a plain hook object.
+    client: async (options) => sdkprovider(await sdk.tester(options)),
+
+    // The SDK supplies its own context wrapper.
+    contextify: (val) => {
+      const utility = sdk.utility()
+      const hook =
+        'function' === typeof utility.contextify ? utility.contextify
+          : 'function' === typeof utility.makeContext ? utility.makeContext
+            : null
+      const ctx = null == hook ? val : hook.call(utility, val)
+      if (null != ctx && 'object' === typeof ctx) {
+        ctx.utility = utility
+
+        // Workaround (b): the runner assigns the provider here right after
+        // this hook returns; hidden, the cycle never enters clone()'s walk.
+        hideprop(ctx, 'client')
+      }
+      return ctx
+    },
+
+    // Client options may reference the runner store.
+    inject: (options, store) => {
+      const structutils = sdk.utility().struct
+      if (structutils && 'function' === typeof structutils.inject) {
+        return structutils.inject(options, store)
+      }
+      return options
+    },
+
+    utility: () => sdk.utility(),
+    tester: (options) => sdk.tester(options),
+    sdk,
+  }
+}
+
+
+// Wrap the SDK as an omni provider WITHOUT hiding it: hooks from sdkhooks,
+// everything else through the prototype chain.
+function sdkprovider(sdk) {
+  const provider = Object.assign(Object.create(sdk), sdkhooks(sdk))
+
+  // Workaround (b), second edge: `provider.sdk` stays readable (tests
+  // unwrap the live SDK through it) but leaves clone()'s walk.
+  hideprop(provider, 'sdk')
+
+  return provider
+}
+
+
+// struct's makeRunner(testfile, client) signature, backed by vendored omni.
+// Also accepts an already-parsed spec object (omni's own capability), which
+// keeps smoke tests free of fixture files.
+async function makeRunner(testfile, client) {
+  const specref = 'string' !== typeof testfile ? testfile
+    : isAbsolute(testfile) ? testfile
+      : join(__dirname, testfile)
+
+  const provider = sdkprovider(client)
+  const runner = await omnimakerunner(specref, provider)
+
+  return async function structrunner(name, store) {
+    const runpack = await runner(name, store)
+
+    return {
+      spec: runpack.spec,
+
+      // Explicitly passed subjects need workaround (a) too — the corpus
+      // tests hand most subjects in per-set rather than by name.
+      runset: async (testspec, testsubject) =>
+        runpack.runset(testspec, wrapsubject(testsubject)),
+      runsetflags: async (testspec, flags, testsubject) =>
+        runpack.runsetflags(testspec, flags, wrapsubject(testsubject)),
+
+      subject: runpack.subject,
+      client: provider,
+    }
+  }
+}
+
+
+// struct's flag-modifier name, served from native omni.
+const nullModifier = nullmodifier
+
+
+module.exports = {
+  EXISTSMARK,
+  NULLMARK,
+  UNDEFMARK,
+  OmniError,
+  makeRunner,
+  nullModifier,
+}