@voxgig/sdkgen 4.9.0 → 4.11.0

package/project/.sdk/tm/lean/test/StructCorpus.lean

@@ -1,368 +0,0 @@
-/- Struct corpus: drives the `struct` subtree of the shared
-   ../.sdk/test/test.json — the project's own compiled corpus, the same file
-   every other target reads — through the vendored voxgig/struct port, on the
-   vendored @voxgig/omni engine.
-
-   The ENGINE is no longer in this file. It used to be: an in-tree JSON
-   reader, `fixJson`, `eqv`, `matchval`, `doMatch`, `resolveArgs`,
-   `checkResult`, `handleError` and `runSet` — this port's own copy of omni's
-   algorithm, drifting from it by construction. All of it is gone; every
-   group below is handed to omni through OmniResolver. What remains is what
-   actually belongs to this SDK: WHICH corpus group drives WHICH struct
-   function, and with which flags.
-
-   The file keeps its name (and the `structcorpus` executable keeps its
-   root), so no call site — Makefile, lakefile, CI — needed churn.
-
-   Flags mirror canonical: typescript/test/utility/StructUtility.test.ts. -/
-
-import VoxgigStruct
-import Omni
-import OmniResolver
-
-open VoxgigStruct
-open OmniResolver
-
--- ---------------- subjects that need more than one expression ----------
-
-def nullModifier : ModifyFn := fun v key parent _inj => do
-  if v == .str nullmark then
-    let _ ← setprop parent key .null
-  else match v with
-    | .str s =>
-      let _ ← setprop parent key (.str (s.replace nullmark "null"))
-    | _ => pure ()
-
-/-- walk/log is authored as one {in, out} pair whose `out.after` is the log of
-an after-walk. The subject builds that log and returns it; the resolver's
-`single (out := ["after"])` selects the half the corpus asserts on. -/
-def walkLogSubject (vin : Value) : SIO Value := do
-  let log ← emptyList
-  let walklog : WalkFn := fun key v parent path => do
-    let ks ← if isNullish key then stringify .noval else stringify key
-    let vs ← stringify v
-    let ps ← if isNullish parent then stringify .noval else stringify parent
-    let ts ← pathify path
-    let n ← size log
-    let _ ← setprop log (vInt n)
-      (.str ("k=" ++ ks ++ ", v=" ++ vs ++ ", p=" ++ ps ++ ", t=" ++ ts))
-    pure v
-  let _ ← walk vin (after := some walklog)
-  pure log
-
-def walkCopySubject (vin : Value) : SIO Value := do
-  let cur ← IO.mkRef (← newList #[.noval])
-  let walkcopy : WalkFn := fun key v _parent path => do
-    if isNullish key then do
-      let seed ← if ismap v then emptyMap else if islist v then emptyList else pure v
-      cur.set (← newList #[seed])
-      pure v
-    else do
-      let i ← size path
-      let iN := i.toNat
-      let nv ← if isnode v then do
-          match (← cur.get) with
-          | .list r => do
-            let mut xs ← listItems r
-            while xs.size <= iN do
-              xs := xs.push .noval
-            let n ← if ismap v then emptyMap else emptyList
-            xs := xs.set! iN n
-            setListItems r xs
-            pure n
-          | _ => pure v
-        else pure v
-      let tgt ← getelem (← cur.get) (vInt (i - 1))
-      let _ ← setprop tgt key nv
-      pure v
-  let _ ← walk vin (before := some walkcopy)
-  getelem (← cur.get) (.num 0.0)
-
-def walkDepthSubject (vin : Value) : SIO Value := do
-  let top ← IO.mkRef Value.noval
-  let curr ← IO.mkRef Value.noval
-  let copy : WalkFn := fun key v _parent _path => do
-    if isNullish key || isnode v then do
-      let child ← if islist v then emptyList else emptyMap
-      if isNullish key then do
-        top.set child
-        curr.set child
-      else do
-        let _ ← setprop (← curr.get) key child
-        curr.set child
-    else
-      let _ ← setprop (← curr.get) key v
-    pure v
-  let _ ← walk (← getp vin "src") (before := some copy) (maxdepth := ← getp vin "maxdepth")
-  top.get
-
--- ---------------- test groups ------------------------------------------
-
-def runAll (r : Run) : SIO Unit := do
-
-  -- minor
-  runset r "minor.isnode" (getset r ["minor", "isnode"])
-    (fun v => pure (.bool (isnode v)))
-  runset r "minor.ismap" (getset r ["minor", "ismap"])
-    (fun v => pure (.bool (ismap v)))
-  runset r "minor.islist" (getset r ["minor", "islist"])
-    (fun v => pure (.bool (islist v)))
-  runset r "minor.iskey" (getset r ["minor", "iskey"])
-    (fun v => pure (.bool (iskey v))) (nullflag := false)
-  runset r "minor.strkey" (getset r ["minor", "strkey"])
-    (fun v => pure (.str (strkey v))) (nullflag := false)
-  runset r "minor.isempty" (getset r ["minor", "isempty"])
-    (fun v => do pure (.bool (← isempty v))) (nullflag := false)
-  runset r "minor.isfunc" (getset r ["minor", "isfunc"])
-    (fun v => pure (.bool (isfunc v)))
-  runset r "minor.clone" (getset r ["minor", "clone"]) clone (nullflag := false)
-  runset r "minor.escre" (getset r ["minor", "escre"]) escre
-  runset r "minor.escurl" (getset r ["minor", "escurl"]) escurl
-  runset r "minor.stringify" (getset r ["minor", "stringify"])
-    (fun vin => do
-      if ← hasp vin "val" then
-        pure (.str (← stringify (← getp vin "val") (maxlen := ← getp vin "max")))
-      else
-        pure (.str (← stringify .noval)))
-    (nullflag := false)
-  runset r "minor.jsonify" (getset r ["minor", "jsonify"])
-    (fun vin => do
-      pure (.str (← jsonify (← getp vin "val") (flags := ← getp vin "flags"))))
-    (nullflag := false)
-  -- `alt` is read by NULLISHNESS here and by PRESENCE for getprop below.
-  -- That is canonical's own split: it omits getprop's alt only when the KEY
-  -- is missing (`undefined === vin.alt`), so a present `alt: null` still
-  -- goes through, while getelem's rule is the looser `null == vin.alt`.
-  -- `minor/getprop#50` and `#51` are the entries that separate them — and
-  -- the retired hand-written engine hid the difference, because its `eqv`
-  -- matched a no-value against a null. The vendored engine does not.
-  runset r "minor.getelem" (getset r ["minor", "getelem"])
-    (fun vin => do
-      let alt ← getp vin "alt"
-      if isNullish alt then getelem (← getp vin "val") (← getp vin "key")
-      else getelem (← getp vin "val") (← getp vin "key") alt)
-    (nullflag := false)
-  runset r "minor.delprop" (getset r ["minor", "delprop"])
-    (fun vin => do delprop (← getp vin "parent") (← getp vin "key"))
-  runset r "minor.size" (getset r ["minor", "size"])
-    (fun v => do pure (vInt (← size v))) (nullflag := false)
-  runset r "minor.slice" (getset r ["minor", "slice"])
-    (fun vin => do
-      slice (← getp vin "val") (start := ← getp vin "start") (stop := ← getp vin "end"))
-    (nullflag := false)
-  runset r "minor.pad" (getset r ["minor", "pad"])
-    (fun vin => do
-      pure (.str (← pad (← getp vin "val") (padding := ← getp vin "pad")
-        (padchar := ← getp vin "char"))))
-    (nullflag := false)
-  runset r "minor.pathify" (getset r ["minor", "pathify"])
-    (fun vin => do
-      if ← hasp vin "path" then
-        pure (.str (← pathify (← getp vin "path") (startin := ← getp vin "from")))
-      else
-        pure (.str (← pathify .noval (startin := ← getp vin "from") (absent := true))))
-    (nullflag := false)
-  runset r "minor.items" (getset r ["minor", "items"]) items
-  runset r "minor.getprop" (getset r ["minor", "getprop"])
-    (fun vin => do
-      if ← hasp vin "alt" then
-        getprop (← getp vin "val") (← getp vin "key") (← getp vin "alt")
-      else getprop (← getp vin "val") (← getp vin "key"))
-    (nullflag := false)
-  runset r "minor.setprop" (getset r ["minor", "setprop"])
-    (fun vin => do
-      setprop (← getp vin "parent") (← getp vin "key") (← getp vin "val"))
-  runset r "minor.haskey" (getset r ["minor", "haskey"])
-    (fun vin => do
-      pure (.bool (← haskey (← getp vin "src") (← getp vin "key"))))
-    (nullflag := false)
-  runset r "minor.keysof" (getset r ["minor", "keysof"])
-    (fun v => do newList ((← keysof v).map (fun s => Value.str s)))
-  runset r "minor.join" (getset r ["minor", "join"])
-    (fun vin => do
-      let url := (← getp vin "url") == .bool true
-      pure (.str (← join (← getp vin "val") (sep := ← getp vin "sep") (url := url))))
-    (nullflag := false)
-  runset r "minor.typify" (getset r ["minor", "typify"])
-    (fun v => pure (vInt (typify v))) (nullflag := false)
-  runset r "minor.setpath" (getset r ["minor", "setpath"])
-    (fun vin => do
-      setpath (← getp vin "store") (← getp vin "path") (← getp vin "val"))
-    (nullflag := false)
-  runset r "minor.filter" (getset r ["minor", "filter"])
-    (fun vin => do
-      let checkV ← getp vin "check"
-      let check : (String × Value) → Bool :=
-        if checkV == .str "gt3" then
-          fun (_, x) => match x with | .num n => n > 3.0 | _ => false
-        else if checkV == .str "lt3" then
-          fun (_, x) => match x with | .num n => n < 3.0 | _ => false
-        else fun _ => false
-      filter (← getp vin "val") check)
-  runset r "minor.typename" (getset r ["minor", "typename"])
-    (fun v => do
-      let t : Int := match v with
-        | .num n => fToInt n
-        | _ => 0
-      pure (.str (typename t)))
-  runset r "minor.flatten" (getset r ["minor", "flatten"])
-    (fun vin => do
-      match (← getp vin "depth") with
-      | .num n => flatten (← getp vin "val") (depth := fToInt n)
-      | _ => flatten (← getp vin "val"))
-
-  -- walk
-  runset r "walk.log" (single (getset r ["walk", "log"]) (out := ["after"]))
-    walkLogSubject
-  runset r "walk.basic" (getset r ["walk", "basic"])
-    (fun vin => do
-      walk vin (after := some (fun _k v _p path => do
-        match v with
-        | .str s => do
-          let mut parts : List String := []
-          for x in (← listItemsOf path) do
-            parts := (← jsString x) :: parts
-          pure (.str (s ++ "~" ++ String.intercalate "." parts.reverse))
-        | _ => pure v)))
-  runset r "walk.copy" (getset r ["walk", "copy"]) walkCopySubject
-  runset r "walk.depth" (getset r ["walk", "depth"]) walkDepthSubject
-    (nullflag := false)
-
-  -- merge
-  runset r "merge.basic" (single (getset r ["merge", "basic"]))
-    (fun vin => do merge (← clone vin))
-  runset r "merge.cases" (getset r ["merge", "cases"]) (fun v => merge v)
-  runset r "merge.array" (getset r ["merge", "array"]) (fun v => merge v)
-  runset r "merge.integrity" (getset r ["merge", "integrity"]) (fun v => merge v)
-  runset r "merge.depth" (getset r ["merge", "depth"])
-    (fun vin => do merge (← getp vin "val") (maxdepth := ← getp vin "depth"))
-
-  -- getpath
-  runset r "getpath.basic" (getset r ["getpath", "basic"])
-    (fun vin => do getpath (← getp vin "store") (← getp vin "path"))
-  runset r "getpath.relative" (getset r ["getpath", "relative"])
-    (fun vin => do
-      let dpath ← match (← getp vin "dpath") with
-        | .str s => newList ((s.splitOn ".").map (fun x => Value.str x)).toArray
-        | _ => pure Value.noval
-      let d : InjDef := { dDparent := ← getp vin "dparent", dDpath := dpath }
-      getpath (← getp vin "store") (← getp vin "path") (.idef d))
-  runset r "getpath.special" (getset r ["getpath", "special"])
-    (fun vin => do
-      let injm ← getp vin "inj"
-      let d : InjDef := {
-        dBase := ← getprop injm (.str "base"), dMeta := ← getprop injm (.str "meta"),
-        dDparent := ← getprop injm (.str "dparent"), dDpath := ← getprop injm (.str "dpath"),
-        dKey := ← getprop injm (.str "key") }
-      getpath (← getp vin "store") (← getp vin "path")
-        (if isNullish injm then .inone else .idef d))
-  runset r "getpath.handler" (getset r ["getpath", "handler"])
-    (fun vin => do
-      let foo ← vFunc (fun _ _ _ _ => pure (.str "foo"))
-      let store ← omapV [("$TOP", ← getp vin "store"), ("$FOO", foo)]
-      let h ← registerFunc (fun _inj v _ref _store => do
-        match v with
-        | .func fid => callFunc fid (← getDummyInj) .noval "" .noval
-        | _ => pure v)
-      let d : InjDef := { dHandler := some h }
-      getpath store (← getp vin "path") (.idef d))
-
-  -- inject
-  runset r "inject.basic" (single (getset r ["inject", "basic"]))
-    (fun vin => do
-      inject (← clone (← getp vin "val")) (← clone (← getp vin "store")))
-  runset r "inject.string" (getset r ["inject", "string"])
-    (fun vin => do
-      let mid ← registerModify nullModifier
-      let d : InjDef := { dModify := some mid, dExtra := ← getp vin "current" }
-      inject (← getp vin "val") (← getp vin "store") (.idef d))
-  runset r "inject.deep" (getset r ["inject", "deep"])
-    (fun vin => do inject (← getp vin "val") (← getp vin "store"))
-
-  -- transform
-  runset r "transform.basic" (single (getset r ["transform", "basic"]))
-    (fun vin => do transform (← getp vin "data") (← getp vin "spec"))
-  for gn in ["paths", "cmds", "each", "pack", "ref"] do
-    runset r ("transform." ++ gn) (getset r ["transform", gn])
-      (fun vin => do transform (← getp vin "data") (← getp vin "spec"))
-  runset r "transform.modify" (getset r ["transform", "modify"])
-    (fun vin => do
-      let mid ← registerModify (fun v key parent _inj => do
-        match v with
-        | .str s =>
-          if !(isNullish key) && !(isNullish parent) then
-            let _ ← setprop parent key (.str ("@" ++ s))
-        | _ => pure ())
-      let d : InjDef := { dModify := some mid, dExtra := ← getp vin "store" }
-      transform (← getp vin "data") (← getp vin "spec") (.idef d))
-  runset r "transform.format" (getset r ["transform", "format"])
-    (fun vin => do transform (← getp vin "data") (← getp vin "spec"))
-    (nullflag := false)
-  runset r "transform.apply" (getset r ["transform", "apply"])
-    (fun vin => do transform (← getp vin "data") (← getp vin "spec"))
-
-  -- validate
-  runset r "validate.basic" (getset r ["validate", "basic"])
-    (fun vin => do validate (← getp vin "data") (← getp vin "spec"))
-    (nullflag := false)
-  for gn in ["child", "one", "exact"] do
-    runset r ("validate." ++ gn) (getset r ["validate", gn])
-      (fun vin => do validate (← getp vin "data") (← getp vin "spec"))
-  runset r "validate.invalid" (getset r ["validate", "invalid"])
-    (fun vin => do validate (← getp vin "data") (← getp vin "spec"))
-    (nullflag := false)
-  runset r "validate.special" (getset r ["validate", "special"])
-    (fun vin => do
-      let injm ← getp vin "inj"
-      let d : InjDef := { dMeta := ← getprop injm (.str "meta") }
-      validate (← getp vin "data") (← getp vin "spec")
-        (if isNullish injm then .inone else .idef d))
-
-  -- select
-  for gn in ["basic", "operators", "edge", "alts"] do
-    runset r ("select." ++ gn) (getset r ["select", gn])
-      (fun vin => do select (← getp vin "obj") (← getp vin "query"))
-
-  -- nullsem: does a PRESENT key holding a JSON null read as "no value"?
-  -- Every group runs {null: false} — the whole point of the section is the
-  -- distinction the null flag would erase.
-  --
-  -- This section used to be looked up as `sentinels`, under six group names
-  -- (`getprop_unify`, `getelem_absent`, `haskey_unify`, `isempty_unify`,
-  -- `isnode_unify`, `stringify_null`) the shipped corpus has never carried —
-  -- alongside a `regex` section it has never carried either. All eleven
-  -- groups therefore ran ZERO cases, silently. The vendored engine names a
-  -- missing group out loud (`SKIP`), which is how that was found; the
-  -- regex groups are gone because this port's `reTest`/`reFind`/... have no
-  -- corpus to answer, and nullsem is driven under the name it actually has.
-  runset r "nullsem.getprop" (getset r ["nullsem", "getprop"])
-    (fun vin => do
-      if ← hasp vin "alt" then
-        getprop (← getp vin "val") (← getp vin "key") (← getp vin "alt")
-      else getprop (← getp vin "val") (← getp vin "key"))
-    (nullflag := false)
-  runset r "nullsem.getelem" (getset r ["nullsem", "getelem"])
-    (fun vin => do
-      if ← hasp vin "alt" then
-        getelem (← getp vin "val") (← getp vin "key") (← getp vin "alt")
-      else getelem (← getp vin "val") (← getp vin "key"))
-    (nullflag := false)
-  runset r "nullsem.getpath" (getset r ["nullsem", "getpath"])
-    (fun vin => do getpath (← getp vin "store") (← getp vin "path"))
-    (nullflag := false)
-  runset r "nullsem.haskey" (getset r ["nullsem", "haskey"])
-    (fun vin => do
-      pure (.bool (← haskey (← getp vin "src") (← getp vin "key"))))
-    (nullflag := false)
-  runset r "nullsem.keysof" (getset r ["nullsem", "keysof"])
-    (fun v => do newList ((← keysof v).map (fun s => Value.str s)))
-    (nullflag := false)
-
--- ---------------- main --------------------------------------------------
-
-def main (argv : List String) : IO UInt32 := do
-  let testfile ← resolveSpecPath argv
-  let r ← makeRun testfile "struct"
-  let sctx ← mkCtx
-  (runAll r).run sctx
-  report r "STRUCT CORPUS: "

package/project/.sdk/tm/lean/test/TFeature.lean

@@ -1,281 +0,0 @@
-/- ProjectName SDK feature test.
-
-   Verifies the feature catalog's OBSERVABLE behaviour. Each feature records
-   into the client's `track` bucket under its own name, so a test activates a
-   feature, runs an operation against the offline (test-mode) transport, and
-   asserts the bucket. Features that wrap the transport are additionally
-   checked for the effect they have on the request or the result. -/
-
-import VoxgigStruct
-import SdkJson
-import SdkUtility
-import SdkFeature
-import SdkFeatures
-import SdkClient
-
-open VoxgigStruct
-
-initialize npass : IO.Ref Nat ← IO.mkRef 0
-initialize nfail : IO.Ref Nat ← IO.mkRef 0
-
-def pass (msg : String) : SIO Unit := do
-  npass.modify (· + 1)
-  IO.println s!"ok   - {msg}"
-
-def fail (msg : String) : SIO Unit := do
-  nfail.modify (· + 1)
-  IO.println s!"FAIL - {msg}"
-
-def check (cond : Bool) (msg : String) : SIO Unit := do
-  if cond then pass msg else fail msg
-
-def gp := SdkUtility.gp
-def gpS := SdkUtility.gpS
-
-def numAt (v : Value) (k : String) : SIO Float := do
-  match (← gp v k) with
-  | .num n => pure n
-  | _ => pure 0.0
-
-/-- A test-mode client with the named features activated. -/
-def clientWith (seed : Value) (feats : Array (String × Value)) : SIO Value := do
-  let fmap ← emptyMap
-  for (n, o) in feats do
-    SdkUtility.sp fmap n o
-  let opts ← emptyMap
-  SdkUtility.sp opts "feature" fmap
-  Sdk.testSdk seed opts
-
-def onOpts (extra : Array (String × Value)) : SIO Value := do
-  let o ← newMap #[("active", .bool true)]
-  for (k, v) in extra do
-    SdkUtility.sp o k v
-  pure o
-
-/-- The bucket a feature records into. -/
-def bucketOf (client : Value) (name : String) : SIO Value := do
-  gp (← gp client "track") name
-
-/-- Does the entity declare this op? -/
-def hasOp (e : Value) (opname : String) : SIO Bool := do
-  match (← gp (← gp e "op") opname) with
-  | .map _ => pure true
-  | _ => pure false
-
-/-- The first entity that has a `list` op AND generated seed data: the feature
-    suite is entity-agnostic, so it discovers its subject from the config.
-    Returns whether the subject also has `create` — the idempotency check is
-    the one case that mutates, and a list-only entity (an API with a read-only
-    collection) has no create ENDPOINT, so calling it raises rather than
-    exercising the feature. Entities carrying both are preferred, so a model
-    that has one keeps the mutating coverage. -/
-def findSubject : SIO (Option (String × Value × Bool)) := do
-  let config ← SdkJson.jsonRead SdkConfig.configJson
-  let ents ← gp config "entity"
-  let mut fallback : Option (String × Value × Bool) := none
-  for name in (← keysof ents) do
-    let e ← gp ents name
-    if ← hasOp e "list" then
-      let Name := name.capitalize
-      let seedPath := "../.sdk/test/entity/" ++ name ++ "/" ++ Name ++ "TestData.json"
-      if ← System.FilePath.pathExists seedPath then
-        let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
-        if ← hasOp e "create" then
-          return some (name, seed, true)
-        if fallback.isNone then
-          fallback := some (name, seed, false)
-  pure fallback
-
-def main : IO UInt32 := do
-  let sctx ← mkCtx
-  let go : SIO Unit := do
-    match (← findSubject) with
-    | none => IO.println "skip - no entity with list op and seed data"
-    | some (ent, seed, hasCreate) => do
-    let mt ← emptyMap
-
-    -- log: counts requests
-    (do
-      let c ← clientWith seed #[("log", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "log"
-      check ((← numAt b "calls") == 1.0) "log: counts one request")
-
-    -- metrics: totals and a per-op bucket
-    (do
-      let c ← clientWith seed #[("metrics", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "metrics"
-      let total ← gp b "total"
-      check ((← numAt total "count") == 2.0) "metrics: counts two operations"
-      check ((← numAt total "ok") == 2.0) "metrics: both recorded ok"
-      let ops ← gp b "ops"
-      check ((← keysof ops).size >= 1) "metrics: per-op bucket created")
-
-    -- telemetry: one span per operation, closed out
-    (do
-      let c ← clientWith seed #[("telemetry", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "telemetry"
-      let spans ← gp b "spans"
-      let n ← (match spans with | .list i => do pure (← listItems i).size | _ => pure 0)
-      check (n == 1) "telemetry: records one span"
-      check ((← numAt b "active") == 0.0) "telemetry: span closed (active back to 0)")
-
-    -- audit: one record per operation
-    (do
-      let c ← clientWith seed #[("audit", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "audit"
-      let recs ← gp b "records"
-      let n ← (match recs with | .list i => do pure (← listItems i).size | _ => pure 0)
-      check (n == 1) "audit: records one operation")
-
-    -- debug: an entry, with sensitive headers redacted
-    (do
-      let c ← clientWith seed #[("debug", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "debug"
-      let entries ← gp b "entries"
-      match entries with
-      | .list i => do
-        let its ← listItems i
-        check (its.size == 1) "debug: records one entry"
-        if its.size > 0 then do
-          let e := its[0]!
-          check ((← gpS e "op") != "") "debug: entry names the operation"
-      | _ => fail "debug: no entries list")
-
-    -- idempotency: injects a key header on mutating ops only
-    (do
-      let c ← clientWith seed #[("idempotency", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b0 ← bucketOf c "idempotency"
-      check ((← numAt b0 "issued") == 0.0) "idempotency: no key for a read op"
-      if hasCreate then
-        let d ← newMap #[("name", .str "idem")]
-        let _ ← SdkRuntime.opCreate c ent d mt
-        let b ← bucketOf c "idempotency"
-        check ((← numAt b "issued") == 1.0) "idempotency: issues a key for create"
-        check ((← gpS b "last") != "") "idempotency: records the issued key")
-
-    -- clienttrack: request/session headers and a request count
-    (do
-      let c ← clientWith seed #[("clienttrack", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "clienttrack"
-      check ((← numAt b "requests") == 1.0) "clienttrack: counts the request"
-      check ((← gpS b "session") != "") "clienttrack: assigns a session id"
-      check ((← gpS b "lastRequestId") != "") "clienttrack: assigns a request id")
-
-    -- rbac: denies when the required permission is absent, allows when granted
-    (do
-      let rules ← newMap #[("list", .str "read")]
-      let c ← clientWith seed #[("rbac", ← onOpts #[("rules", rules)])]
-      let denied ← (try
-          let _ ← SdkRuntime.opList c ent mt mt
-          pure false
-        catch _ => pure true)
-      check denied "rbac: denies an operation without the permission"
-      let b ← bucketOf c "rbac"
-      check ((← numAt b "denied") == 1.0) "rbac: records the denial")
-    (do
-      let rules ← newMap #[("list", .str "read")]
-      let perms ← newList #[.str "read"]
-      let c ← clientWith seed #[("rbac", ← onOpts #[("rules", rules), ("perms", perms)])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "rbac"
-      check ((← numAt b "allowed") == 1.0) "rbac: allows when the permission is granted")
-
-    -- cache: second identical read is served from the cache
-    (do
-      let c ← clientWith seed #[("cache", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "cache"
-      check ((← numAt b "miss") == 1.0) "cache: first read is a miss"
-      check ((← numAt b "hit") == 1.0) "cache: second read is a hit")
-
-    -- ratelimit: a tight burst throttles
-    (do
-      let c ← clientWith seed #[("ratelimit", ← onOpts #[("rate", .num 1.0), ("burst", .num 1.0)])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "ratelimit"
-      check ((← numAt b "throttled") >= 1.0) "ratelimit: throttles the second call")
-
-    -- netsim: offline simulation fails the request
-    (do
-      let c ← clientWith seed #[("netsim", ← onOpts #[("offline", .bool true)])]
-      let failed ← (try
-          let _ ← SdkRuntime.opList c ent mt mt
-          pure false
-        catch _ => pure true)
-      check failed "netsim: offline simulation fails the request"
-      let b ← bucketOf c "netsim"
-      check ((← numAt b "calls") == 1.0) "netsim: records the simulated call")
-
-    -- netsim: failStatus is surfaced as the response status
-    (do
-      let c ← clientWith seed #[("netsim", ← onOpts #[("failStatus", .num 503.0)])]
-      let _ ← (try
-          let _ ← SdkRuntime.opList c ent mt mt
-          pure ()
-        catch _ => pure ())
-      let b ← bucketOf c "netsim"
-      check ((← numAt b "calls") == 1.0) "netsim: failStatus simulation runs")
-
-    -- proxy: annotates the transport and records the route
-    (do
-      let c ← clientWith seed #[("proxy", ← onOpts #[("url", .str "http://proxy.local:8080")])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "proxy"
-      check ((← numAt b "routed") == 1.0) "proxy: routes the request"
-      check ((← gpS b "url") == "http://proxy.local:8080") "proxy: records the proxy url")
-
-    -- timeout: a generous budget does not trip
-    (do
-      let c ← clientWith seed #[("timeout", ← onOpts #[("ms", .num 30000.0)])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      pass "timeout: request within budget succeeds")
-
-    -- retry: a healthy transport is not retried
-    (do
-      let c ← clientWith seed #[("retry", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "retry"
-      check ((← numAt b "attempts") == 0.0) "retry: no retry on a healthy response")
-
-    -- paging: annotates the query and counts items
-    (do
-      let c ← clientWith seed #[("paging", ← onOpts #[("size", .num 2.0)])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "paging"
-      check ((← numAt b "pages") == 1.0) "paging: counts the page"
-      check ((← numAt b "items") >= 1.0) "paging: counts the returned items")
-
-    -- streaming: reports the emitted items
-    (do
-      let c ← clientWith seed #[("streaming", ← onOpts #[])]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "streaming"
-      check ((← numAt b "emitted") >= 1.0) "streaming: emits the list items"
-      check ((← numAt b "chunks") == 1.0) "streaming: reports one chunk")
-
-    -- an inactive feature records nothing
-    (do
-      let off ← newMap #[("active", .bool false)]
-      let c ← clientWith seed #[("log", off)]
-      let _ ← SdkRuntime.opList c ent mt mt
-      let b ← bucketOf c "log"
-      match b with
-      | .map _ => fail "inactive feature must not record"
-      | _ => pass "inactive feature records nothing")
-
-  go.run sctx
-  let p ← npass.get
-  let f ← nfail.get
-  IO.println ""
-  IO.println s!"feature: PASS {p}  FAIL {f}"
-  if f > 0 then return 1 else return 0