@voxgig/sdkgen-langpack 0.0.1

package/.sdk/tm/lean/test/OmniResolver.lean

@@ -0,0 +1,358 @@
+/- The corpus test runner: the VENDORED @voxgig/omni port (test/vendor/omni/
+   Omni.lean) driven through its NATIVE API (`Omni.makeRunnerSpec` /
+   `RunPack.runsetflagsargs`), presented to the corpus suites in the shape
+   they already use (`runspec`, `getset`, `runset`, `runsetArgs`, `report`).
+
+   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). It is the Lean peer of tm/ocaml/test/omni_resolver.ml and
+   tm/java/test/OmniResolver.java — omni's provider is closure-based, so
+   nothing in omni ever has to name this SDK's types.
+
+   The engine used to live FUSED inside the two corpus suites: each carried
+   its own JSON reader, fixJson, deep equality, matchval/doMatch,
+   resolveArgs, checkResult, handleError and runSet. Both were rewritten in
+   place onto this file, so both KEEP THEIR NAMES and no emitted call site
+   needed churn — which is why nothing is listed as `superseded` for this
+   target.
+
+   Lean-specific decisions, each load-bearing:
+
+   1. omni IS PURE, THIS SDK IS NOT. omni's `Subject` is
+      `List Val → Except String Val`, a pure function; this SDK's struct port
+      keeps its nodes in a heap threaded through `SIO` (a `ReaderT Ctx IO`),
+      because Lean has no mutable value semantics. The subject callback is the
+      one place the two meet, so it runs the action with `unsafeIO` — the
+      escape hatch Lean provides for exactly this, and the same bridge
+      voxgig/struct's own Lean corpus runner uses. TEST CODE ONLY: nothing
+      under src/ names `runsio`.
+
+   2. TWO VALUE MODELS, ONE CONVERSION PAIR. `Omni.Val` (`Option Lean.Json`)
+      and `VoxgigStruct.Value` are different types, so every crossing is an
+      explicit `tostruct` / `toomni`. omni's `none` (ABSENT) becomes this
+      port's `.noval` and `Json.null` becomes `.null`, which keeps the two
+      no-value states the corpus distinguishes apart — and is why Lean needs
+      neither go's `novalargs` spec rewrite nor lua/php's compat shim for the
+      corpus's ZERO-ARGUMENT entries. An entry with no `in`/`args`/`ctx`
+      reaches the subject as one `Omni.Val` of `none`, which becomes exactly
+      this port's own no-value, so `typify` answers T_NOVAL where a null
+      would answer T_NULL.
+
+   3. ARGUMENTS ARE WRITTEN BACK. `Omni.SubjectArgs` is the channel omni
+      provides for a subject that MUTATES its arguments, which
+      `match: {args: ...}` then asserts on — `struct/minor/setpath` (7
+      entries here) and `struct/merge/integrity` (6) turn on it. Decision 2
+      hands the subject a CONVERTED COPY on this SDK's heap, and `Lean.Json`
+      is immutable, so every subject here runs through `runsetflagsargs` and
+      the wrapper converts the (possibly mutated) values back into omni's
+      own list after the call. A dynamic port's shim gets this free from
+      shared object identity; Lean cannot.
+
+   4. `match: {ctx: ...}` IS RETARGETED ONTO `match: {args: {"0": ...}}`.
+      A VALUE-SEMANTICS consequence, not a choice. omni's `drive` stores the
+      contextified first argument as `entry.ctx` AND as `args[0]` — two
+      copies of an immutable value — and `checkresult` reads `entry.ctx` for
+      the ctx base. A subject's post-call writes (decision 3) can never reach
+      that copy, and NINE `primary` entries assert exactly the post-call
+      state (makeRequest, makeResponse, makeSpec, param, prepareAuth,
+      resultBody, resultHeaders, transformRequest, transformResponse).
+      `args[0]` IS the ctx of a ctx entry (omni itself sets
+      `args = [entry.ctx]`), and the runner reads that list back after an
+      args-subject call — so moving the assertion from `ctx` to `args.0`
+      reads the SAME map, post-call, and preserves every leaf: nothing is
+      dropped, weakened or skipped. `retargetctx` below does that rewrite on
+      the spec handed to the engine. OCaml, Rust and Swift face the identical
+      problem and answer it identically; the upstream fix is for the port's
+      `drive` to re-point `entry.ctx` at the returned `args[0]`, the way JS
+      object identity does implicitly — a follow-up, never a hand-edit of a
+      vendored file.
+
+   5. KEY ORDER. omni's Lean port models a map as `Lean.Json.obj`, whose
+      container is key-SORTED (the vendored file says so itself), while this
+      SDK's `Value` map is insertion-ordered. Every map in the shipped corpus
+      is key-sorted, so the round trip is order-preserving in practice — and
+      `Omni.deepequal` compares maps order-independently in any case. A
+      corpus that ever ships an unsorted map would need the upstream fix
+      (omni's own value model), never a hand-edit here.
+
+   6. FAILURES ARE ACCUMULATED, NOT RAISED. omni stops a group at its first
+      bad entry and returns the message; the corpus suites report the whole
+      corpus in one run. `drive` records the message and carries on, so one
+      run still names every broken GROUP. A group that is ABSENT from the
+      corpus, or present with an empty set, is recorded in `skipped` and
+      printed by `report` — named out loud, never a silent vacuous pass. -/
+
+import VoxgigStruct
+import Omni
+
+open VoxgigStruct
+
+namespace OmniResolver
+
+-- ---------------- the sentinels, under the corpus's own names ----------
+
+def nullmark : String := Omni.nullmark
+def undefmark : String := Omni.undefmark
+def existsmark : String := Omni.existsmark
+
+-- ---------------- decision 1: the SIO <-> pure bridge ------------------
+
+unsafe def runsioImpl {α : Type} [Inhabited α] (ctx : Ctx) (act : SIO α)
+    : Except String α :=
+  match unsafeIO (act.run ctx) with
+  | .ok value => .ok value
+  | .error err => .error err.toString
+
+@[implemented_by runsioImpl]
+opaque runsio {α : Type} [Inhabited α] (ctx : Ctx) (act : SIO α) : Except String α
+
+-- ---------------- decision 2: the value models -------------------------
+
+/-- omni's model -> this SDK's. Nodes are built through `newList` /
+`emptyMap`, so what a subject receives is a real heap node it may rewrite in
+place (decision 3). -/
+partial def tostruct (value : Omni.Val) : SIO Value := do
+  match value with
+  | none => pure .noval
+  | some .null => pure .null
+  | some (.bool flag) => pure (.bool flag)
+  | some (.num entry) => pure (.num entry.toFloat)
+  | some (.str text) => pure (.str text)
+  | some (.arr entries) => do
+    let mut out : Array Value := #[]
+    for entry in entries do
+      out := out.push (← tostruct (some entry))
+    newList out
+  | some (.obj kvs) => do
+    let m ← emptyMap
+    for kv in kvs.toArray do
+      let _ ← setprop m (.str kv.1) (← tostruct (some kv.2))
+    pure m
+
+/-- This SDK's model -> omni's. A function or a sentinel has no JSON form and
+omni only ever stringifies one, so it becomes its own rendering rather than
+silently collapsing to null — an unexpected one then FAILS visibly instead of
+vanishing. -/
+partial def toomni (value : Value) : SIO Omni.Val := do
+  match value with
+  | .noval => pure none
+  | .null => pure (some Lean.Json.null)
+  | .bool flag => pure (some (Lean.Json.bool flag))
+  | .num n => pure (some (
+      -- Whole values keep their integer spelling; anything else goes through
+      -- the float constructor, which is the only lossless route Lean offers.
+      if n == n.floor && n.abs < 9007199254740992.0 then
+        Lean.Json.num (Lean.JsonNumber.fromInt (Int.ofNat n.abs.toUInt64.toNat
+          |> fun m => if n < 0.0 then -m else m))
+      else
+        match Lean.JsonNumber.fromFloat? n with
+        | .inr number => Lean.Json.num number
+        | .inl _ => Lean.Json.null))
+  | .str text => pure (some (Lean.Json.str text))
+  | .list id => do
+    let mut out : Array Lean.Json := #[]
+    for item in (← listItems id) do
+      out := out.push ((← toomni item).getD Lean.Json.null)
+    pure (some (Lean.Json.arr out))
+  | .map id => do
+    let mut out : List (String × Lean.Json) := []
+    for (k, v) in (← mapEntries id) do
+      out := (k, (← toomni v).getD Lean.Json.null) :: out
+    pure (some (Lean.Json.mkObj out.reverse))
+  | .func _ => pure (some (Lean.Json.str "[Function]"))
+  | .sentinel tag => pure (some (Lean.Json.str ("`$" ++ tag ++ "`")))
+
+/-- Order-independent deep equality, through omni's own rule so a suite's
+hand-written comparison matches the way every group is checked. -/
+def eqv (a b : Value) : SIO Bool := do
+  pure (Omni.deepequal (← toomni a) (← toomni b))
+
+-- ---------------- value helpers (re-homed from the fused runners) ------
+
+/-- Raw property read: a stored `null` is preserved, an absent key answers
+`.noval`. NOT `SdkUtility.gp`, which collapses the two. -/
+def getp (value : Value) (key : String) : SIO Value := do
+  match value with
+  | .map id => pure ((omapGet (← mapEntries id) key).getD .noval)
+  | _ => pure .noval
+
+def hasp (value : Value) (key : String) : SIO Bool := do
+  match value with
+  | .map id => pure (omapHas (← mapEntries id) key)
+  | _ => pure false
+
+def omapV (pairs : List (String × Value)) : SIO Value := do
+  let m ← emptyMap
+  for (key, value) in pairs do
+    let _ ← setprop m (.str key) value
+  pure m
+
+/-- One of omni's arguments, absent answering `.noval`. -/
+def arg (args : Array Value) (index : Nat) : Value := args[index]?.getD .noval
+
+-- ---------------- the run ----------------------------------------------
+
+/-- One corpus run: the engine's pack, plus the accumulated tally
+(decision 6). The counters are `IO.Ref`s because a Lean structure is
+immutable and every suite drives dozens of groups in sequence. -/
+structure Run where
+  pack : Omni.RunPack
+  pass : IO.Ref Nat
+  groups : IO.Ref Nat
+  failures : IO.Ref (Array String)
+  skipped : IO.Ref (Array String)
+
+/-- Every provider hook is optional and this SDK needs none of them: subjects
+are passed explicitly per group (so `subject` is unused), no suite builds a
+client from a corpus `DEF.client` block (so `client` is unused), contexts stay
+maps across the runner (decision 4, so `contextify` is unused), and no corpus
+entry asserts on an error CODE, so omni's own {name,message} errify is exactly
+right. -/
+def provider : Omni.Provider := Omni.emptyProvider
+
+def makeRunSpec (alltests : Lean.Json) (name : String) : IO Run := do
+  let pack ← match Omni.makeRunnerSpec alltests provider name with
+    | .ok pack => pure pack
+    | .error message => throw (IO.userError message)
+  let pass ← IO.mkRef 0
+  let groups ← IO.mkRef 0
+  let failures ← IO.mkRef (#[] : Array String)
+  let skipped ← IO.mkRef (#[] : Array String)
+  pure { pack, pass, groups, failures, skipped }
+
+def makeRun (testfile : String) (name : String) : IO Run := do
+  makeRunSpec (← Omni.loadspec testfile) name
+
+/-- Where the shared corpus lives: the first command-line argument, else
+$SDK_TEST_SPEC, else the usual relative positions. The first candidate is the
+fallback so a missing file is reported by name. -/
+def specCandidates : Array String :=
+  #["../.sdk/test/test.json", ".sdk/test/test.json", "test/test.json"]
+
+def resolveSpecPath (argv : List String) : IO String := do
+  match argv.head? with
+  | some given => pure given
+  | none =>
+    match (← IO.getEnv "SDK_TEST_SPEC") with
+    | some given => pure given
+    | none => do
+      for candidate in specCandidates do
+        if ← System.FilePath.pathExists candidate then
+          return candidate
+      pure specCandidates[0]!
+
+/-- The resolved section of the spec (omni's `primary.<name>`, then `<name>`,
+then the whole spec). -/
+def runspec (r : Run) : Lean.Json := r.pack.spec
+
+/-- A named group, by a path of keys from the resolved section. -/
+def getset (r : Run) (keys : List String) : Omni.Val :=
+  keys.foldl (fun acc key => Omni.jget acc key) (some r.pack.spec)
+
+/-- A corpus group authored as ONE `{in, out}` pair rather than a set —
+`merge/basic`, `inject/basic`, `transform/basic`, `walk/log`. Wrapped into a
+one-entry set so it runs through the SAME engine as everything else instead of
+a bespoke code path beside it. `out` selects a sub-path of the authored `out`
+(walk/log asserts only on `out.after`). -/
+def single (node : Omni.Val) (out : List String := []) : Omni.Val :=
+  let expected := out.foldl (fun acc key => Omni.jget acc key) (Omni.jget node "out")
+  some (Omni.jmap [("set", Omni.jlist [
+    Omni.jmap [("in", (Omni.jget node "in").getD Lean.Json.null),
+               ("out", expected.getD Lean.Json.null)]])])
+
+-- ---------------- decision 4: retarget match.ctx -----------------------
+
+def retargetctx (testspec : Lean.Json) : Lean.Json :=
+  match Omni.aslist (Omni.jget (some testspec) "set") with
+  | none => testspec
+  | some entries =>
+    let rewrite (raw : Lean.Json) : Lean.Json :=
+      let check := Omni.jget (some raw) "match"
+      if Omni.ismap (some raw) && Omni.ismap check && Omni.jhas check "ctx"
+          && !Omni.jhas check "args"
+          && (Omni.jhas (some raw) "ctx" || Omni.jhas (some raw) "args") then
+        -- Drop the original leaf: it would read the stale pre-call copy omni
+        -- keeps in `entry.ctx`.
+        let kept := ((Omni.asmap check).getD []).filter (fun kv => kv.1 != "ctx")
+        let leaf := (Omni.jget check "ctx").getD Lean.Json.null
+        Omni.jset raw "match"
+          (Omni.jmap (kept ++ [("args", Omni.jmap [("0", leaf)])]))
+      else raw
+    Omni.jset testspec "set" (Lean.Json.arr (entries.map rewrite))
+
+-- ---------------- driving one group ------------------------------------
+
+def entrycount (node : Omni.Val) : Int :=
+  match Omni.aslist (Omni.jget node "set") with
+  | some entries => (entries.size : Int)
+  | none => -1
+
+def oneline (text : String) : String :=
+  String.intercalate " | " (text.splitOn "\n")
+
+def drive (r : Run) (nullflag : Bool) (label : String) (node : Omni.Val)
+    (call : Omni.SubjectArgs) : IO Unit := do
+  let count := entrycount node
+  if count <= 0 then
+    -- Absent, malformed, or empty. NAMED, never silent: a group that stopped
+    -- running is the failure mode the vendored engine exists to prevent.
+    let why :=
+      if Omni.isabsent node then "absent from corpus"
+      else if count == 0 then "empty set" else "no set"
+    r.skipped.modify (·.push s!"{label} ({why})")
+  else do
+    r.groups.modify (· + 1)
+    match r.pack.runsetflagsargs (retargetctx (node.getD Lean.Json.null))
+        { null := nullflag, name := some label } call with
+    | .ok () => r.pass.modify (· + count.toNat)
+    | .error message => r.failures.modify (·.push (oneline message))
+
+/-- The subject wrapper: convert in, call, convert the (possibly mutated)
+arguments and the result back out (decisions 1, 2 and 3). -/
+def wrapArgs (ctx : Ctx) (subject : Array Value → SIO Value) : Omni.SubjectArgs :=
+  fun cells =>
+    runsio ctx (do
+      let mut vals : Array Value := #[]
+      for cell in cells do
+        vals := vals.push (← tostruct cell)
+      let res ← subject vals
+      let mut back : Array Omni.Val := #[]
+      for value in vals do
+        back := back.push (← toomni value)
+      pure (back.toList, ← toomni res))
+
+/-- Run one group whose subject takes omni's whole argument list. This is the
+shape the `primary` suite needs: a `ctx` entry arrives as `args[0]`, a MAP,
+which the call site turns into a live context and writes the observable state
+back into (decisions 3 and 4). -/
+def runsetArgs (r : Run) (label : String) (node : Omni.Val)
+    (subject : Array Value → SIO Value) (nullflag : Bool := true) : SIO Unit := do
+  drive r nullflag label node (wrapArgs (← read) subject)
+
+/-- Run one group whose subject takes the entry's single argument. -/
+def runset (r : Run) (label : String) (node : Omni.Val)
+    (subject : Value → SIO Value) (nullflag : Bool := true) : SIO Unit :=
+  runsetArgs r label node (fun vals => subject (arg vals 0)) nullflag
+
+-- ---------------- reporting --------------------------------------------
+
+def report (r : Run) (heading : String) : IO UInt32 := do
+  for message in (← r.failures.get) do
+    IO.println ("FAIL " ++ message)
+  for note in (← r.skipped.get) do
+    IO.println ("SKIP " ++ note)
+  let passed ← r.pass.get
+  let grouped ← r.groups.get
+  let failed := (← r.failures.get).size
+  let skips := (← r.skipped.get).size
+  IO.println ""
+  IO.println s!"{heading}PASS {passed}  FAIL {failed}"
+  IO.println s!"{heading}GROUPS {grouped}  SKIPPED {skips}"
+  -- A run that executes nothing is not a pass.
+  if passed == 0 then do
+    IO.println (heading ++ "the corpus executed no cases")
+    return 1
+  if 0 < failed then return 1
+  return 0
+
+end OmniResolver

package/.sdk/tm/lean/test/OmniSmoke.lean

@@ -0,0 +1,174 @@
+/- ProjectName SDK omni runner smoke test.
+
+   Smoke tests for the VENDORED @voxgig/omni engine itself
+   (test/vendor/omni/Omni.lean), and for the load-bearing decisions in
+   OmniResolver. A runner that cannot FAIL a bad entry would turn every
+   corpus suite vacuously green, so the FAILURE paths are pinned here, not
+   just the happy one. (Lean peer of ocaml's test/omni_smoke_test.ml, ts's
+   test/omni.test.ts and lua's test/omni_smoke_test.lua.)
+
+   The spec is built IN MEMORY, in omni's own value model — no fixture file,
+   and no OMNI block (lenient v0, like the shared corpus). -/
+
+import VoxgigStruct
+import Omni
+import OmniResolver
+
+open VoxgigStruct
+open OmniResolver
+
+-- ---------------- a tiny assertion harness ----------------
+
+initialize npass : IO.Ref Nat ← IO.mkRef 0
+initialize nfail : IO.Ref Nat ← IO.mkRef 0
+
+def check (name : String) (cond : Bool) : IO Unit := do
+  if cond then npass.modify (· + 1)
+  else do
+    nfail.modify (· + 1)
+    IO.println ("FAIL " ++ name)
+
+def contains (hay needle : String) : Bool :=
+  needle.isEmpty || 1 < (hay.splitOn needle).length
+
+/-- Exactly one recorded failure, and it names `want`. -/
+def onefailure (name : String) (r : Run) (want : String) : IO Unit := do
+  let msgs ← r.failures.get
+  if msgs.size == 1 then
+    check (name ++ ": failure mentions " ++ want) (contains (msgs[0]?.getD "") want)
+  else
+    check (name ++ ": expected exactly one failure, got " ++ toString msgs.size) false
+
+-- ---------------- the in-memory spec ----------------
+
+def num (n : Int) : Lean.Json := Omni.jnum n
+
+def makespec : Lean.Json :=
+  Omni.jmap [("primary", Omni.jmap [("smoke", Omni.jmap [
+
+    ("basic", Omni.jmap [("set", Omni.jlist [
+      Omni.jmap [("in", num 1), ("out", num 2)],
+      Omni.jmap [("in", num 41), ("out", num 42)]])]),
+
+    ("bad", Omni.jmap [("set", Omni.jlist [
+      Omni.jmap [("in", num 1), ("out", num 999)]])]),
+
+    ("err", Omni.jmap [("set", Omni.jlist [
+      Omni.jmap [("in", num 0), ("err", Omni.jstr "zero refused")]])]),
+
+    ("empty", Omni.jmap [("set", Omni.jlist [])]),
+
+    -- Resolver decision 3: a subject that MUTATES its argument, which
+    -- `match.args` then asserts on. Without the write-back this passes
+    -- vacuously — the assertion would read the unmutated input.
+    ("mutate", Omni.jmap [("set", Omni.jlist [
+      Omni.jmap [("in", Omni.jmap [("x", num 1)]),
+                 ("match", Omni.jmap [("args", Omni.jmap [("0", Omni.jmap [("x", num 2)])])]),
+                 ("out", num 2)]])]),
+
+    -- Resolver decision 4: `match: {ctx: ...}` must read the POST-call ctx.
+    -- omni's own `entry.ctx` is a pre-call copy, so without the retarget
+    -- this entry fails.
+    ("ctx", Omni.jmap [("set", Omni.jlist [
+      Omni.jmap [("ctx", Omni.jmap [("a", num 1)]),
+                 ("match", Omni.jmap [("ctx", Omni.jmap [("b", num 2)])]),
+                 ("out", num 1)]])])
+
+  ])])]
+
+def pack : IO Run := makeRunSpec makespec "smoke"
+
+-- ---------------- subjects ----------------
+
+def inc (v : Value) : SIO Value := do
+  match v with
+  | .num n => if n == 0.0 then throw (IO.userError "smoke: zero refused")
+              else pure (.num (n + 1.0))
+  | other => pure other
+
+def identity (v : Value) : SIO Value := pure v
+
+/-- Mutates its argument in place and returns the new value. -/
+def bump (v : Value) : SIO Value := do
+  let _ ← setprop v (.str "x") (.num 2.0)
+  pure (.num 2.0)
+
+/-- Does NOT mutate: the negative control for decision 3. -/
+def nobump (_v : Value) : SIO Value := pure (.num 2.0)
+
+/-- Writes a key onto the ctx map AFTER it was handed over: the positive
+control for decision 4. -/
+def ctxwrite (args : Array Value) : SIO Value := do
+  let _ ← setprop (arg args 0) (.str "b") (.num 2.0)
+  pure (.num 1.0)
+
+def ctxnowrite (_args : Array Value) : SIO Value := pure (.num 1.0)
+
+-- ---------------- the tests ----------------
+
+def main : IO UInt32 := do
+  let sctx ← mkCtx
+
+  -- A correct subject passes, and every case is counted.
+  let r ← pack
+  (runset r "basic" (getset r ["basic"]) inc).run sctx
+  check "basic: no failures" (← r.failures.get).isEmpty
+  check "basic: both cases ran" ((← r.pass.get) == 2)
+  check "basic: one group driven" ((← r.groups.get) == 1)
+
+  -- A wrong result FAILS, and the resolver records it rather than swallowing
+  -- it. This is the anti-vacuity check the whole rollout exists for.
+  let r ← pack
+  (runset r "bad" (getset r ["bad"]) inc).run sctx
+  onefailure "bad" r "result mismatch"
+  check "bad: no case counted as passing" ((← r.pass.get) == 0)
+
+  -- An expected error is matched.
+  let r ← pack
+  (runset r "err" (getset r ["err"]) inc).run sctx
+  check "err: expected error matched" (← r.failures.get).isEmpty
+  check "err: case counted" ((← r.pass.get) == 1)
+
+  -- An expected error that does NOT occur must fail.
+  let r ← pack
+  (runset r "err" (getset r ["err"]) identity).run sctx
+  onefailure "err-missing" r "expected error did not occur"
+
+  -- A group absent from the spec is NAMED, never a silent pass.
+  let r ← pack
+  (runset r "nosuch" (getset r ["nosuch"]) inc).run sctx
+  check "absent: no failures" (← r.failures.get).isEmpty
+  check "absent: nothing counted" ((← r.pass.get) == 0)
+  check "absent: named as skipped" ((← r.skipped.get).size == 1)
+
+  -- An EMPTY set is likewise named, not counted as a pass.
+  let r ← pack
+  (runset r "empty" (getset r ["empty"]) inc).run sctx
+  check "empty: nothing counted" ((← r.pass.get) == 0)
+  check "empty: named as skipped" ((← r.skipped.get).size == 1)
+
+  -- Decision 3: argument mutation reaches `match.args`.
+  let r ← pack
+  (runset r "mutate" (getset r ["mutate"]) bump).run sctx
+  check "mutate: write-back reaches match.args" (← r.failures.get).isEmpty
+  check "mutate: case counted" ((← r.pass.get) == 1)
+
+  let r ← pack
+  (runset r "mutate" (getset r ["mutate"]) nobump).run sctx
+  onefailure "mutate-missing" r "match failed at args.0.x"
+
+  -- Decision 4: `match.ctx` reads the POST-call ctx.
+  let r ← pack
+  (runsetArgs r "ctx" (getset r ["ctx"]) ctxwrite).run sctx
+  check "ctx: retarget reaches post-call ctx" (← r.failures.get).isEmpty
+  check "ctx: case counted" ((← r.pass.get) == 1)
+
+  let r ← pack
+  (runsetArgs r "ctx" (getset r ["ctx"]) ctxnowrite).run sctx
+  onefailure "ctx-missing" r "match failed at args.0.b"
+
+  let p ← npass.get
+  let f ← nfail.get
+  IO.println ""
+  IO.println s!"OMNI SMOKE: PASS {p}  FAIL {f}"
+  if f > 0 then return 1 else return 0