@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/scala/sdktest/OmniSmoke.scala

@@ -0,0 +1,192 @@
+// Smoke test for the vendored omni runner ITSELF.
+//
+// A runner that cannot FAIL a bad entry would turn every corpus suite
+// vacuously green, so this pins the failure paths, not just the happy one:
+// a wrong result must be reported, and an expected error that does NOT
+// occur must be reported. It also exercises the whole adapter — the
+// in-memory spec capability, the Json <-> Value bridge, and OmniReport's
+// accumulation — because those are what stand between the vendored engine
+// and the two corpus mains.
+//
+// The Scala peer of tm/java/test/OmniSmokeTest.java, tm/lua/test/
+// omni_smoke_test.lua and tm/ts/test/omni.test.ts. There is no test
+// framework in this target (see model/target/scala.aon), so it is a plain
+// scala-cli main that exits non-zero on failure, like the corpus mains
+// beside it.
+
+import voxgig.omni.Json as OJson
+import voxgig.struct.{Noval, VNum, Value}
+
+object OmniSmoke {
+
+  // A minimal in-memory spec: no fixture file, no OMNI block (lenient v0,
+  // like the shared corpus). Built in omni's OWN value model - the runner
+  // walks nothing else.
+  def smokespec(): OJson = OJson.map(
+    "primary" -> OJson.map(
+      "smoke" -> OJson.map(
+        "basic" -> OJson.map(
+          "set" -> OJson.list(
+            OJson.map("in" -> OJson.num(1), "out" -> OJson.num(2)),
+            OJson.map("in" -> OJson.num(41), "out" -> OJson.num(42)))),
+        "bad" -> OJson.map(
+          "set" -> OJson.list(
+            OJson.map("in" -> OJson.num(1), "out" -> OJson.num(999)))),
+        "err" -> OJson.map(
+          "set" -> OJson.list(
+            OJson.map("in" -> OJson.num(0), "err" -> OJson.str("zero refused")))),
+        // A single {in, out} node rather than a `set`: the shape the four
+        // struct groups OmniRun.compare drives have.
+        "node" -> OJson.map("in" -> OJson.num(7), "out" -> OJson.num(7)))))
+
+  // The subject under test, in this SDK's struct value model - so a pass
+  // here also proves the resolver's Json <-> Value bridge round-trips.
+  def inc(v: Value): Value = v match {
+    case VNum(n) if 0.0 == n => throw new RuntimeException("smoke: zero refused")
+    case VNum(n)             => VNum(n + 1.0)
+    case other               => other
+  }
+
+  def identity(v: Value): Value = v
+
+  private var nfail = 0
+
+  private def check(what: String, ok: Boolean, detail: String): Unit =
+    if (ok) println("ok   " + what)
+    else { nfail += 1; println("FAIL " + what + " - " + detail) }
+
+  private def run(name: String, group: String, subject: Value => Value): OmniReport = {
+    val report = new OmniReport("")
+    val spec = smokespec()
+    val run = OmniResolver.section(OmniResolver.makeRunner(spec), spec, "smoke", report)
+    run.runset(name, run.group(group))(subject)
+    report
+  }
+
+  private def freshrun(section: String, report: OmniReport): OmniRun = {
+    val spec = smokespec()
+    OmniResolver.section(OmniResolver.makeRunner(spec), spec, section, report)
+  }
+
+  def main(args: Array[String]): Unit = {
+    // 0. The section and its groups resolve at all.
+    val spec = smokespec()
+    val resolved =
+      OmniResolver.section(OmniResolver.makeRunner(spec), spec, "smoke",
+        new OmniReport("")).set("basic")
+    check("smoke section resolves", !resolved.isabsent, "primary.smoke did not resolve")
+
+    // 1. A correct subject passes, and every entry is counted.
+    val good = run("smoke.basic", "basic", inc)
+    check("runset passes a correct subject", good.failures.isEmpty,
+      good.failures.mkString(" | "))
+    check("runset counts every entry", 2 == good.passed,
+      "expected 2 checks, counted " + good.passed)
+
+    // 1b. The count is what the ENGINE RAN, not what the spec declares
+    //     (OmniResolver decision 8). Counted here at the subject, the far
+    //     side of the engine: a number the engine cannot move is not
+    //     evidence that the engine ran.
+    var calls = 0
+    val counted = run("smoke.basic", "basic", v => { calls += 1; inc(v) })
+    check("the reported count is what the engine ran",
+      2 == calls && calls == counted.passed,
+      "the engine invoked the subject " + calls + " times but the report " +
+        "counted " + counted.passed + " passes")
+
+    // 2. A WRONG result is reported. Without this the corpus suites would be
+    //    vacuously green.
+    val bad = run("smoke.bad", "bad", inc)
+    check("runset fails a wrong result", bad.failures.nonEmpty,
+      "a wrong result went unreported - the corpus suites would be vacuously green")
+    check("the failure names the mismatch",
+      bad.failures.exists(_.contains("result mismatch")),
+      "expected a result mismatch failure, got: " + bad.failures.mkString(" | "))
+    check("a failed group counts nothing", 0 == bad.passed,
+      "a failed group still counted " + bad.passed + " passes")
+
+    // 3. An expected error is matched; a MISSING expected error is reported.
+    val raised = run("smoke.err", "err", inc)
+    check("an expected error is matched", raised.failures.isEmpty,
+      raised.failures.mkString(" | "))
+
+    val missed = run("smoke.err", "err", identity)
+    check("a missing expected error fails", missed.failures.nonEmpty,
+      "a missing expected error went unreported")
+    check("the failure names the missing error",
+      missed.failures.exists(_.contains("expected error did not occur")),
+      "expected an expected-error failure, got: " + missed.failures.mkString(" | "))
+
+    // 4. Absence, BOTH kinds (OmniResolver decision 7). Neither is ever a
+    //    silent pass, and the two are not the same fact.
+    //
+    // 4a. The section is carried and the GROUP is gone. That is a corpus
+    //     regression - it must FAIL, because a skip would let the group stop
+    //     running behind a green banner.
+    val gone = new OmniReport("")
+    val gonerun = freshrun("smoke", gone)
+    gonerun.runset("smoke.nosuch", gonerun.group("nosuch"))(inc)
+    check("a group missing from a section this corpus carries fails",
+      gone.failures.exists(_.contains("smoke.nosuch")) && 0 == gone.passed,
+      "absent group: failures=" + gone.failures.mkString(" | ") +
+        " passed=" + gone.passed + " skipped=" + gone.skipped.mkString(","))
+
+    // 4b. The whole SECTION is missing - a project corpus older than the
+    //     section (struct.nullsem, fleet-wide). SKIPPED and NAMED, not
+    //     failed, and never counted as a pass.
+    val older = new OmniReport("")
+    val olderrun = freshrun("smoke", older)
+    olderrun.runset("nosuch.basic", olderrun.group("nosuch", "basic"))(inc)
+    check("a group whose whole section is absent is skipped, not passed",
+      older.skipped.exists(_.startsWith("nosuch.basic")) && 0 == older.passed &&
+        older.failures.isEmpty,
+      "absent section: skipped=" + older.skipped.mkString(",") +
+        " passed=" + older.passed + " failures=" + older.failures.mkString(" | "))
+
+    // 4c. `compare` - the single-node groups (merge/basic, inject/basic,
+    //     transform/basic, walk/log) - is held to the SAME rule. It used to
+    //     have no guard at all: an absent node became Noval on both sides,
+    //     fixjson rendered both as NULLMARK, and NULLMARK deep-equals
+    //     NULLMARK, so three struct groups could stop running and leave a run
+    //     bit-identical to a healthy one.
+    val nonode = new OmniReport("")
+    val nonoderun = freshrun("smoke", nonode)
+    nonoderun.compare("smoke.nonode", nonoderun.group("nonode"), Noval, Noval)
+    check("compare fails an absent single-node group, never passes it",
+      nonode.failures.exists(_.contains("smoke.nonode")) && 0 == nonode.passed,
+      "absent compare node: failures=" + nonode.failures.mkString(" | ") +
+        " passed=" + nonode.passed + " skipped=" + nonode.skipped.mkString(","))
+
+    // 4d. A node that IS there but carries no in/out pair compares nothing
+    //     for the same reason, so the shape is checked before the values.
+    val hollow = new OmniReport("")
+    val hollowrun = freshrun("smoke", hollow)
+    hollowrun.compare("smoke.hollow", hollowrun.group("bad"), Noval, Noval)
+    check("compare fails a node with no in/out pair",
+      hollow.failures.exists(_.contains("no in/out")) && 0 == hollow.passed,
+      "hollow compare node: failures=" + hollow.failures.mkString(" | ") +
+        " passed=" + hollow.passed)
+
+    // 4e. And a WELL-FORMED single-node group still passes, so 4c/4d are a
+    //     guard and not a blanket refusal.
+    val onenode = new OmniReport("")
+    val onenoderun = freshrun("smoke", onenode)
+    onenoderun.compare("smoke.node", onenoderun.group("node"),
+      OmniResolver.tostruct(onenoderun.group("node").node.get("out")),
+      OmniResolver.tostruct(onenoderun.group("node").node.get("in")))
+    check("compare passes a well-formed single-node group",
+      onenode.failures.isEmpty && 1 == onenode.passed,
+      "single node: failures=" + onenode.failures.mkString(" | ") +
+        " passed=" + onenode.passed)
+
+    // 5. A report that checked NOTHING must fail, not pass: a whole corpus
+    //    section going missing is exactly how a suite goes vacuously green.
+    val empty = new OmniReport("")
+    empty.requireran("nothing")
+    check("a run that checked nothing fails", empty.failures.nonEmpty,
+      "an empty run passed - a missing corpus section would go unnoticed")
+
+    println("\nOMNI SMOKE FAIL " + nfail)
+    if (0 < nfail) System.exit(1)
+  }
+}

package/project/.sdk/tm/scala/sdktest/PrimaryCorpus.scala

@@ -1,10 +1,14 @@
 // Primary-utility corpus driver.
 //
 // Drives every `primary` section of the shared corpus (../.sdk/test/test.json)
-// through this SDK's utilities, the way the ts reference harness does. The
-// match/args/err machinery is reused from Runner (StructCorpus.scala); what
-// this file adds is the bridge between the corpus Value ADT and the SDK's
-// Java-collection world, plus a live Context built from each corpus entry.
+// through this SDK's utilities, the way the ts reference harness does.
+//
+// The ENGINE is the vendored @voxgig/omni runner (sdktest/vendor/omni),
+// reached through sdktest/OmniResolver.scala — this file was REWRITTEN IN
+// PLACE by the vendor-tag rollout and keeps its name, so no emitted call site
+// moved. What it still owns is the bridge only this SDK can supply: the
+// corpus Value ADT <-> the SDK's Java-collection world, plus a live Context
+// built from each corpus entry and published back for `match` to read.
 
 import voxgig.struct.{clone as sclone, *}
 import SCALAPACKAGE.core.*
@@ -31,6 +35,8 @@ object PrimaryCorpus {
     case VNum(n)  =>
       // The corpus writes whole numbers as JSON integers; handing the SDK a
       // Double turned "1" into "1.0" everywhere it reached a URL or header.
+      // (omni parses every JSON number as a Double, so the narrowing has to
+      // happen on THIS boundary, not the omni one.)
       if (n == Math.floor(n) && !n.isInfinite) java.lang.Long.valueOf(n.toLong)
       else java.lang.Double.valueOf(n)
     case _ => null
@@ -72,15 +78,22 @@ object PrimaryCorpus {
 
   // ---- corpus access -----------------------------------------------------
 
-  private var CORPUS: Value = Noval
+  // The whole corpus, and the omni runner built over it. One RunnerPack for
+  // the run; a section is resolved from it on demand (omni's own
+  // `primary.<name>` lookup, so the section names below ARE the corpus
+  // lookup keys).
+  private var ALL: voxgig.omni.Json = voxgig.omni.Json.Absent
+  private var PACK: voxgig.omni.RunnerPack = null
+  private var REPORT: OmniReport = null
 
-  private def sectionBasic(name: String): Value = vget(vget(vget(CORPUS, "primary"), name), "basic")
+  private def sectionRun(name: String): OmniRun =
+    OmniResolver.section(PACK, ALL, name, REPORT)
 
   // makeSpec and prepareAuth read defaults off the CLIENT, as the ts reference
   // does via client.options(), so a section's DEF.setup cannot reach them
   // through ctx.options — those sections get their own client.
-  private def sectionSetup(name: String): Value =
-    vget(vget(vget(vget(vget(CORPUS, "primary"), name), "DEF"), "setup"), "a")
+  private def sectionSetup(run: OmniRun): Value =
+    OmniResolver.tostruct(run.set("DEF", "setup", "a"))
 
   // ---- live context from a corpus map ------------------------------------
 
@@ -151,11 +164,17 @@ object PrimaryCorpus {
 
   // The match reads the corpus map while the utilities mutate the live objects
   // hanging off the context, so without this every ctx.* assertion reads null.
+  //
+  // The map written here is args(0), which the resolver converts BACK into
+  // omni's own argument list after the call — that is why the `match: {ctx:
+  // ...}` assertions are retargeted onto `match: {args: {"0": ...}}`
+  // (OmniResolver decision 3): omni's Json is an immutable value model, so
+  // the copy it keeps in `entry.ctx` can never see these writes.
   private def publishCtx(ctxmap: Value, ctx: Context): Unit = ctxmap match {
     case VMap(m) =>
       if (ctx.spec != null) m.put("spec", specValue(ctx.spec))
       if (ctx.result != null) m.put("result", resultValue(ctx.result))
-      if (ctx.response != null) m.put("response", VStr(Runner.EXISTSMARK))
+      if (ctx.response != null) m.put("response", VStr(OmniResolver.EXISTSMARK))
     case _ =>
   }
 
@@ -191,29 +210,37 @@ object PrimaryCorpus {
 
   private def argAt(args: Seq[Value], i: Int): Value = if (i < args.length) args(i) else Noval
 
-  // A section driven with a ctx built from the corpus entry.
-  private def runset(name: String, client: ProjectNameSDK)(f: (Context, Seq[Value]) => Value): Unit =
-    Runner.runSet(name, sectionBasic(name), (args: Seq[Value]) => {
+  // A section driven with a ctx built from the corpus entry. `run.group`
+  // rather than `run.set`: the group carries its parent, so a `basic` that
+  // has gone missing out of a section this corpus carries FAILS instead of
+  // being skipped past (OmniResolver decision 7).
+  private def runset(name: String, client: ProjectNameSDK)(f: (Context, Seq[Value]) => Value): Unit = {
+    val run = sectionRun(name)
+    run.runsetargs(name, run.group("basic")) { args =>
       val ctxmap = argAt(args, 0)
       val ctx = corpusCtx(client, ctxmap)
       val out = f(ctx, args)
       publishCtx(ctxmap, ctx)
       out
-    })
+    }
+  }
 
   // A section that takes a bare map or explicit args rather than a ctx.
-  private def runsetArgs(name: String)(f: Seq[Value] => Value): Unit =
-    Runner.runSet(name, sectionBasic(name), f)
+  private def runsetArgs(name: String)(f: Seq[Value] => Value): Unit = {
+    val run = sectionRun(name)
+    run.runsetargs(name, run.group("basic"))(f)
+  }
 
   private def clientFor(name: String, shared: ProjectNameSDK): ProjectNameSDK =
-    sectionSetup(name) match {
+    sectionSetup(sectionRun(name)) match {
       case m @ VMap(_) => ProjectNameSDK.testSDK(null, jmap(m))
       case _           => shared
     }
 
   def run(testfile: String): Int = {
-    val src = new String(java.nio.file.Files.readAllBytes(java.nio.file.Paths.get(testfile)), "UTF-8")
-    CORPUS = Runner.jsonRead(src)
+    ALL = OmniResolver.loadspec(testfile)
+    PACK = OmniResolver.makeRunner(ALL)
+    REPORT = new OmniReport("PRIMARY CORPUS: ")
 
     val sdk = ProjectNameSDK.testSDK()
     val u = sdk.getUtility()
@@ -282,7 +309,8 @@ object PrimaryCorpus {
       VMap(m)
     }
 
-    Runner.reportPrimary()
+    REPORT.requireran("primary")
+    REPORT.finish()
   }
 }
 

package/project/.sdk/tm/scala/sdktest/vendor/omni/Json.scala

@@ -0,0 +1,229 @@
+// VENDORED: @voxgig/omni sdk-20260904-1610-0 (scala/src/Json.scala)
+// 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.
+// The omni JSON value model, with a small in-tree parser.
+//
+// The omni runner must be able to test *any* library, and must add no
+// third-party dependencies, so it carries its own JSON support rather than
+// borrowing circe, upickle or the system under test.
+
+package voxgig.omni
+
+import scala.collection.immutable.ListMap
+
+/** A JSON value. `Absent` is the marker for "no value at all", as distinct
+  * from `Null`.
+  */
+enum Json:
+  case Absent
+  case Null
+  case Bool(value: Boolean)
+  case Num(value: Double)
+  case Str(value: String)
+  case JList(value: List[Json])
+  case JMap(value: ListMap[String, Json])
+
+  def ismap: Boolean = this match
+    case JMap(_) => true
+    case _       => false
+
+  def islist: Boolean = this match
+    case JList(_) => true
+    case _        => false
+
+  def isnode: Boolean = ismap || islist
+
+  def isabsent: Boolean = this match
+    case Absent => true
+    case _      => false
+
+  def isnull: Boolean = this match
+    case Null => true
+    case _    => false
+
+  def isnone: Boolean = isabsent || isnull
+
+  def isnum: Boolean = this match
+    case Num(_) => true
+    case _      => false
+
+  def isstr: Boolean = this match
+    case Str(_) => true
+    case _      => false
+
+  def asnum: Option[Double] = this match
+    case Num(value) => Some(value)
+    case _          => None
+
+  def asstr: Option[String] = this match
+    case Str(value) => Some(value)
+    case _          => None
+
+  def aslist: Option[List[Json]] = this match
+    case JList(value) => Some(value)
+    case _            => None
+
+  def asmap: Option[ListMap[String, Json]] = this match
+    case JMap(value) => Some(value)
+    case _           => None
+
+  /** Read a map entry. Returns Absent when missing. */
+  def get(key: String): Json = this match
+    case JMap(value) => value.getOrElse(key, Absent)
+    case _           => Absent
+
+  /** Is a map key present at all (even with a null value)? */
+  def has(key: String): Boolean = this match
+    case JMap(value) => value.contains(key)
+    case _           => false
+
+  /** A copy of this map with one entry set. */
+  def set(key: String, entry: Json): Json = this match
+    case JMap(value) => JMap(value.updated(key, entry))
+    case other       => other
+
+object Json:
+  def map(entries: (String, Json)*): Json = JMap(ListMap.from(entries))
+
+  def list(entries: Json*): Json = JList(entries.toList)
+
+  def num(value: Double): Json = Num(value)
+
+  def str(value: String): Json = Str(value)
+
+  /** Parse JSON text into the omni value model. */
+  def parse(text: String): Json =
+    val parser = Parser(text)
+    parser.skipws()
+    val value = parser.value()
+    parser.skipws()
+    if !parser.done then throw OmniError(s"omni: trailing JSON content at ${parser.pos}")
+    value
+
+  private class Parser(val text: String):
+    var pos: Int = 0
+
+    def done: Boolean = pos >= text.length
+
+    def skipws(): Unit =
+      while !done && (text(pos) == ' ' || text(pos) == '\t' || text(pos) == '\n' || text(pos) == '\r')
+      do pos += 1
+
+    def value(): Json =
+      if done then throw OmniError("omni: unexpected end of JSON")
+
+      text(pos) match
+        case '{' => mapval()
+        case '[' => listval()
+        case '"' => Json.Str(strval())
+        case 't' => word("true"); Json.Bool(true)
+        case 'f' => word("false"); Json.Bool(false)
+        case 'n' => word("null"); Json.Null
+        case _   => numval()
+
+    def word(want: String): Unit =
+      if !text.startsWith(want, pos) then throw OmniError(s"omni: bad JSON literal at $pos")
+      pos += want.length
+
+    def mapval(): Json =
+      var out = ListMap.empty[String, Json]
+      pos += 1 // {
+
+      skipws()
+      if !done && text(pos) == '}' then
+        pos += 1
+        return Json.JMap(out)
+
+      var running = true
+      while running do
+        skipws()
+        val key = strval()
+        skipws()
+
+        if done || text(pos) != ':' then throw OmniError(s"omni: expected ':' at $pos")
+        pos += 1
+
+        skipws()
+        out = out.updated(key, value())
+        skipws()
+
+        if done then throw OmniError("omni: unterminated JSON object")
+        if text(pos) == ',' then pos += 1
+        else if text(pos) == '}' then
+          pos += 1
+          running = false
+        else throw OmniError(s"omni: expected ',' or '}' at $pos")
+
+      Json.JMap(out)
+
+    def listval(): Json =
+      val out = scala.collection.mutable.ListBuffer.empty[Json]
+      pos += 1 // [
+
+      skipws()
+      if !done && text(pos) == ']' then
+        pos += 1
+        return Json.JList(out.toList)
+
+      var running = true
+      while running do
+        skipws()
+        out += value()
+        skipws()
+
+        if done then throw OmniError("omni: unterminated JSON array")
+        if text(pos) == ',' then pos += 1
+        else if text(pos) == ']' then
+          pos += 1
+          running = false
+        else throw OmniError(s"omni: expected ',' or ']' at $pos")
+
+      Json.JList(out.toList)
+
+    def strval(): String =
+      if done || text(pos) != '"' then throw OmniError(s"omni: expected string at $pos")
+      pos += 1
+
+      val out = StringBuilder()
+
+      while !done do
+        val ch = text(pos)
+        pos += 1
+
+        if ch == '"' then return out.toString
+
+        if ch != '\\' then out.append(ch)
+        else
+          if done then throw OmniError("omni: unterminated JSON string")
+          val escape = text(pos)
+          pos += 1
+          escape match
+            case '"'  => out.append('"')
+            case '\\' => out.append('\\')
+            case '/'  => out.append('/')
+            case 'b'  => out.append('\b')
+            case 'f'  => out.append('\f')
+            case 'n'  => out.append('\n')
+            case 'r'  => out.append('\r')
+            case 't'  => out.append('\t')
+            case 'u' =>
+              if pos + 4 > text.length then throw OmniError("omni: bad JSON unicode escape")
+              out.append(Integer.parseInt(text.substring(pos, pos + 4), 16).toChar)
+              pos += 4
+            case other => throw OmniError(s"omni: bad JSON escape [$other] at $pos")
+
+      throw OmniError("omni: unterminated JSON string")
+
+    def numval(): Json =
+      val start = pos
+
+      if !done && (text(pos) == '-' || text(pos) == '+') then pos += 1
+
+      while !done && (text(pos).isDigit || text(pos) == '.' || text(pos) == 'e' ||
+          text(pos) == 'E' || text(pos) == '-' || text(pos) == '+')
+      do pos += 1
+
+      val span = text.substring(start, pos)
+      span.toDoubleOption match
+        case Some(value) => Json.Num(value)
+        case None        => throw OmniError(s"omni: bad JSON number [$span] at $start")