@voxgig/sdkgen-langpack 0.0.1

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

@@ -0,0 +1,368 @@
+/- 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/.sdk/tm/lean/test/TFeature.lean

@@ -0,0 +1,281 @@
+/- 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