@voxgig/sdkgen 4.3.0 → 4.4.1

package/project/.sdk/tm/go/test/feature_corpus_test.go

@@ -20,6 +20,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"sort"
 	"strings"
 	"testing"
 
@@ -184,6 +185,23 @@ func fcCandidates(client *sdk.ProjectNameSDK) []fcOp {
 			})
 		}
 	}
+
+	// SAFE OPS FIRST — see the ts harness for the reasoning: the cache stores
+	// only successful GETs, so an SDK whose first usable op is a `create`
+	// (POST) can never satisfy "a hit served from cache costs nothing".
+	safe := map[string]int{"list": 0, "load": 1}
+	rank := func(o fcOp) int {
+		if r, ok := safe[strings.ToLower(o.method)]; ok {
+			return r
+		}
+		return 2
+	}
+	sort.SliceStable(out, func(i, j int) bool {
+		if rank(out[i]) != rank(out[j]) {
+			return rank(out[i]) < rank(out[j])
+		}
+		return out[i].key < out[j].key
+	})
 	return out
 }
 

package/project/.sdk/tm/java/test/FeatureCorpusTest.java

@@ -182,6 +182,14 @@ public class FeatureCorpusTest {
         out.add(new Op(e.getKey() + "." + opname, accessor, call));
       }
     }
+
+    // SAFE OPS FIRST — see the ts harness for the reasoning: the cache stores
+    // only successful GETs, so an SDK whose first usable op is a `create`
+    // (POST) can never satisfy "a hit served from cache costs nothing".
+    java.util.Map<String, Integer> safe = java.util.Map.of("list", 0, "load", 1);
+    out.sort(java.util.Comparator
+        .<Op>comparingInt(o -> safe.getOrDefault(o.key.substring(o.key.indexOf('.') + 1), 2))
+        .thenComparing(o -> o.key));
     return out;
   }
 

package/project/.sdk/tm/js/test/feature/Corpus.test.js

@@ -109,7 +109,12 @@ function candidates(client) {
       out.push({ key: entity + '.' + op, accessor: accessor[entity], entity, op })
     }
   }
-  return out
+  // SAFE OPS FIRST — see the ts harness for the reasoning: the cache stores
+  // only successful GETs, so an SDK whose first usable op is a `create`
+  // (POST) can never satisfy "a hit served from cache costs nothing".
+  const SAFE = { list: 0, load: 1 }
+  return out.sort((a, b) =>
+    ((SAFE[a.op] ?? 2) - (SAFE[b.op] ?? 2)) || a.key.localeCompare(b.key))
 }
 
 

package/project/.sdk/tm/kotlin/utility/MakeOptions.kt

@@ -2,6 +2,7 @@ package KOTLINPACKAGE.utility
 
 import KOTLINPACKAGE.core.Context
 import KOTLINPACKAGE.core.Helpers
+import KOTLINPACKAGE.core.Utility
 import KOTLINPACKAGE.utility.struct.Struct
 
 @Suppress("UNCHECKED_CAST")
@@ -11,11 +12,20 @@ fun makeOptions(ctx: Context): MutableMap<String, Any?> {
     options = linkedMapOf()
   }
 
-  // Merge custom utility overrides onto the utility object.
+  // Merge utility overrides from options onto the utility object.
   // Read from original options before clone for parity with the donors.
+  //
+  // A key naming a real utility member REPLACES it; anything else is attached
+  // as a custom extra. Shelving everything in `custom` - a map nothing reads -
+  // made `utility = mapOf("fetcher" to ...)`, the documented transport seam, a
+  // silent no-op here while ts honoured it.
   val customUtils = Helpers.toMapAny(options["utility"])
   if (customUtils != null && ctx.utility != null) {
-    ctx.utility!!.custom.putAll(customUtils)
+    for ((key, value) in customUtils) {
+      if (!overrideUtil(ctx.utility!!, key, value)) {
+        ctx.utility!!.custom[key] = value
+      }
+    }
   }
 
   var opts = Struct.clone(options) as MutableMap<String, Any?>
@@ -165,3 +175,47 @@ fun makeOptions(ctx: Context): MutableMap<String, Any?> {
 
   return opts
 }
+
+
+/**
+ * Replaces one utility member from `options.utility`, matching the ts
+ * reference: a key naming a real member REPLACES it, and any other key is
+ * attached as a custom extra. Returns false when the key names no member or
+ * the value is not that member's type, so the caller keeps it in `custom`.
+ *
+ * REFLECTION, NOT A KEYED SWITCH. The go and java ports list every member by
+ * hand and carry a "keep this in step with registerAll" warning, because a
+ * utility added to one list and not the other is overridable there and not
+ * here. The field set is readable off the class, so the list cannot drift.
+ *
+ * Kotlin function types erase to FunctionN, so `isInstance` checks arity and
+ * not the full signature - the same limit java's port documents. A wrongly
+ * shaped value of the right arity is accepted, exactly as the dynamic donors
+ * accept whatever they are given.
+ *
+ * Only a PUBLIC name may replace a member: public utility names are camelCase
+ * and carry no underscore, so an underscore means the caller named something
+ * of their own rather than a member.
+ */
+internal fun overrideUtil(utility: Utility, key: String, value: Any?): Boolean {
+  if (key.isEmpty() || key.contains('_') || "custom" == key) {
+    return false
+  }
+  if (null == value) {
+    return false
+  }
+
+  val field = try {
+    Utility::class.java.getDeclaredField(key)
+  } catch (e: NoSuchFieldException) {
+    return false
+  }
+
+  if (!field.type.isInstance(value)) {
+    return false
+  }
+
+  field.isAccessible = true
+  field.set(utility, value)
+  return true
+}

package/project/.sdk/tm/lua/utility/make_options.lua

@@ -5,13 +5,33 @@ local vs = require("utility.struct.struct")
 local function make_options_util(ctx)
   local options = ctx.options or {}
 
-  -- Merge custom utility overrides.
+  -- Merge utility overrides from options onto the utility object.
+  --
+  -- A key naming a real utility member REPLACES it; anything else is attached
+  -- as a custom extra. Shelving everything in `custom` - a table nothing reads
+  -- - made `utility = { fetcher = ... }`, the documented transport seam, a
+  -- silent no-op here while ts honoured it.
+  --
+  -- Option keys are camelCase, as ts spells them; members here are
+  -- snake_case. Only a PUBLIC name may replace: public utility names carry no
+  -- underscore, so an underscore means the caller named something of their
+  -- own - possibly the internal spelling of a real member. `make_error` must
+  -- stay an extension, or a non-callable would break the error path on the
+  -- next request.
   local custom_utils = vs.getprop(options, "utility")
   if type(custom_utils) == "table" then
     local utility = ctx.utility
     if utility ~= nil then
       for key, val in pairs(custom_utils) do
-        utility.custom[key] = val
+        local member = nil
+        if type(key) == "string" and not key:find("_") then
+          member = key:gsub("(%u)", function(c) return "_" .. c:lower() end)
+        end
+        if member ~= nil and member ~= "custom" and utility[member] ~= nil then
+          utility[member] = val
+        else
+          utility.custom[key] = val
+        end
       end
     end
   end

package/project/.sdk/tm/ocaml/Makefile

@@ -34,11 +34,16 @@ SDK_TEST = $(RUNTIME) sdk_config.ml $(ENTITIES) sdk_client.ml sdk_error.ml \
   $(ENTITY_TESTS) $(DOC_TESTS) test/t_main.ml
 
 CORPUS_SRC = utility/vregex.ml utility/voxgig_struct.ml sdk_json.ml \
-  test/struct_corpus.ml
+  test/corpus_runner.ml test/struct_corpus.ml
 
-.PHONY: test test-sdk test-corpus build lint clean
+# The primary-utility corpus needs the whole SDK, because it drives the SDK's
+# own request-shaping utilities — not just the struct library.
+PRIMARY_SRC = $(RUNTIME) sdk_config.ml $(ENTITIES) sdk_client.ml sdk_error.ml \
+  test/corpus_runner.ml test/primary_utility_test.ml
 
-test: test-sdk test-corpus
+.PHONY: test test-sdk test-corpus test-primary build lint clean
+
+test: test-sdk test-corpus test-primary
 
 test-sdk: run_sdk_test
 	./run_sdk_test
@@ -50,7 +55,13 @@ run_sdk_test: $(SDK_TEST)
 	$(OCAMLC) $(INC) $(SDK_TEST) -o run_sdk_test
 
 run_struct_corpus: $(CORPUS_SRC)
-	$(OCAMLC) -I utility $(CORPUS_SRC) -o run_struct_corpus
+	$(OCAMLC) -I utility -I test $(CORPUS_SRC) -o run_struct_corpus
+
+test-primary: run_primary_corpus
+	./run_primary_corpus $(CORPUS)
+
+run_primary_corpus: $(PRIMARY_SRC)
+	$(OCAMLC) $(INC) $(PRIMARY_SRC) -o run_primary_corpus
 
 # Type-check the SDK library (a clean compile means it is sound).
 build: lint

package/project/.sdk/tm/ocaml/sdk_features.ml

@@ -592,6 +592,230 @@ let audit_feature () : feature =
         | _ -> ());
   f
 
+(* ------------------------------------------------------------------ *)
+(* cost                                                                *)
+(* ------------------------------------------------------------------ *)
+(* Prices every transport ATTEMPT and commits the spend once per
+   OPERATION. Mirrors tm/ts/src/feature/cost/CostFeature.ts; the corpus
+   cases are .sdk/test/feature/cost.aon.
+
+   ORDER MATTERS. Cost must sit INSIDE the cache, or a response served from
+   cache is charged for money that was never spent. Activate in array form
+   with cost first: [{ name: 'cost' }, { name: 'cache' }]. *)
+
+let cost_feature () : feature =
+  let options = ref (empty_map ()) in
+  (* Per-context accumulation: attempts are priced as they happen and the
+     total is committed once, at PreDone. *)
+  let pending : (string, value) Hashtbl.t = Hashtbl.create 8 in
+  let seq = ref 0 in
+  let f = { f_name = "cost"; f_version = "0.0.1"; f_active = true; f_options = Noval;
+            f_init = (fun _ _ -> ()); f_hook = (fun _ _ -> ()) } in
+
+  let per_unit () = opt_num !options "perUnit" ~default:0. in
+  let limit () = opt_num !options "budget" ~default:0. in
+
+  let record ctx =
+    let cl = cc ctx in
+    track_bucket cl "cost" (fun () ->
+        jo [("currency", Str (opt_str !options "currency" ~default:"USD"));
+            ("total", jo [("calls", Num 0.); ("attempts", Num 0.); ("amount", Num 0.);
+                          ("reported", Num 0.); ("estimated", Num 0.)]);
+            ("ops", empty_map ()); ("actors", empty_map ());
+            ("budget", jo [("limit", Num (limit ())); ("spent", Num 0.);
+                           ("remaining", Num (limit ())); ("exceeded", Bool false)]);
+            ("last", Noval)]) in
+
+  let new_pending () =
+    jo [("attempts", Num 0.); ("amount", Num 0.); ("reported", Num 0.);
+        ("estimated", Num 0.); ("source", Str "none"); ("piped", Bool false)] in
+
+  let pending_for ctx =
+    match Hashtbl.find_opt pending ctx.c_id with
+    | Some p -> p
+    | None -> let p = new_pending () in Hashtbl.replace pending ctx.c_id p; p in
+
+  (* A header figure is server-stated, so it beats the table and the unit. *)
+  let price_header res =
+    let name = opt_str !options "header" ~default:"" in
+    if name = "" then None
+    else match header_ci (getp res "headers") name with
+      | Noval | Null -> None
+      | v -> (match float_of_string_opt (vstr_of v) with
+          | Some n -> Some (n *. per_unit (), "header")
+          | None -> None) in
+
+  (* Same lookup grammar as rbac's rules: '<entity>.<op>', then '<op>',
+     then '*'. *)
+  let price_rate ctx =
+    let rates = match getp !options "rates" with Map _ as m -> m | _ -> empty_map () in
+    let entity = match ctx.c_entity with
+      | Some e -> e.e_name
+      | None -> ctx.c_op.op_entity in
+    let opname = ctx.c_op.op_name in
+    let pick k = match getp rates k with Num n -> Some n | _ -> None in
+    match pick (entity ^ "." ^ opname) with
+    | Some n -> Some (n, "table")
+    | None -> (match pick opname with
+        | Some n -> Some (n, "table")
+        | None -> (match pick "*" with Some n -> Some (n, "table") | None -> None)) in
+
+  let price ctx res =
+    match price_header res with
+    | Some p -> p
+    | None ->
+      match price_rate ctx with
+      | Some p -> p
+      | None ->
+        let unit = opt_num !options "unit" ~default:0. in
+        if unit <> 0. then (unit, "unit") else (0., "none") in
+
+  (* A usage figure from the parsed result body, priced by perUnit. Read at
+     commit, not at the transport seam, because the body is one-shot. *)
+  let price_body ctx =
+    let path = opt_str !options "path" ~default:"" in
+    if path = "" then None
+    else match ctx.c_result with
+      | None -> None
+      | Some rt ->
+        (match rt.rt_body with
+         | Map _ ->
+           (match getpath_s rt.rt_body path with
+            | Num n -> Some (n *. per_unit ())
+            | Str s -> (match float_of_string_opt s with
+                | Some n -> Some (n *. per_unit ()) | None -> None)
+            | _ -> None)
+         | _ -> None) in
+
+  let spend rec_ amount reported estimated =
+    let total = getp rec_ "total" in
+    bump_num total "amount" amount;
+    bump_num total "reported" reported;
+    bump_num total "estimated" estimated;
+    let budget = getp rec_ "budget" in
+    let lim = match getp budget "limit" with Num n -> n | _ -> 0. in
+    let spent = match getp total "amount" with Num n -> n | _ -> 0. in
+    setp budget "spent" (Num spent);
+    setp budget "remaining" (Num (if lim > 0. then max 0. (lim -. spent) else 0.));
+    if lim > 0. && spent >= lim then setp budget "exceeded" (Bool true) in
+
+  let bump bucket key amount =
+    let b = match getp bucket key with
+      | Map _ as m -> m
+      | _ -> let m = jo [("calls", Num 0.); ("amount", Num 0.)] in setp bucket key m; m in
+    bump_num b "calls" 1.;
+    bump_num b "amount" amount in
+
+  let commit ctx p entity opname =
+    let rec_ = record ctx in
+    let amount = ref (match getp p "amount" with Num n -> n | _ -> 0.) in
+    let reported = ref (match getp p "reported" with Num n -> n | _ -> 0.) in
+    let estimated = ref (match getp p "estimated" with Num n -> n | _ -> 0.) in
+    let source = ref (vstr_of (getp p "source")) in
+
+    (* A body figure prices the whole call, so it REPLACES the per-attempt
+       estimate rather than adding to it - and, being server-stated, the
+       whole amount counts as reported. *)
+    (match price_body ctx with
+     | Some b -> amount := b; reported := b; estimated := 0.; source := "body"
+     | None -> ());
+
+    spend rec_ !amount !reported !estimated;
+
+    let actor = match ctx.c_ctrl.ctrl_actor with
+      | Str a when a <> "" -> a
+      | _ -> opt_str !options "actor" ~default:"anonymous" in
+
+    bump_num (getp rec_ "total") "calls" 1.;
+    bump (getp rec_ "ops") (entity ^ "." ^ opname) !amount;
+    bump (getp rec_ "actors") actor !amount;
+
+    incr seq;
+    setp rec_ "last"
+      (jo [("seq", Num (float_of_int !seq)); ("entity", Str entity); ("op", Str opname);
+           ("actor", Str actor); ("amount", Num !amount);
+           ("currency", getp rec_ "currency"); ("source", Str !source);
+           ("attempts", getp p "attempts")]) in
+
+  let finish ctx done_ =
+    if f.f_active then
+      match Hashtbl.find_opt pending ctx.c_id with
+      | None -> ()
+      | Some p ->
+        Hashtbl.remove pending ctx.c_id;
+        let attempts = match getp p "attempts" with Num n -> n | _ -> 0. in
+        (* A FAILED operation that made no attempt never reached the network:
+           the budget gate (or rbac, or an unresolvable endpoint) refused it.
+           Committing would count a call that never happened.
+
+           A SUCCEEDED operation that made no attempt is the opposite case: it
+           was served from the cache. That is a real call, and the fact that it
+           cost nothing is the whole point of ordering cost inside the cache. *)
+        if done_ || attempts > 0. then begin
+          let entity = if ctx.c_op.op_entity <> "" then ctx.c_op.op_entity else "_" in
+          let opname = if ctx.c_op.op_name <> "" then ctx.c_op.op_name else "_" in
+          commit ctx p entity opname
+        end in
+
+  let charge ctx url fetchdef inner =
+    (* A rejecting transport still costs an attempt: without this a run of
+       connection-level failures under `retry` would be charged nothing, and
+       an onBudget: 'deny' ceiling could never stop it. *)
+    let (res, err) = inner ctx url fetchdef in
+    let (amount, source) = price ctx res in
+    let p = pending_for ctx in
+    bump_num p "attempts" 1.;
+    bump_num p "amount" amount;
+    bump_num p (if source = "header" || source = "body" then "reported" else "estimated") amount;
+    setp p "source" (Str source);
+    bump_num (getp (record ctx) "total") "attempts" 1.;
+
+    (* direct() and graphql() dispatch no pipeline hooks at all - no PrePoint
+       to gate on and no PreDone to commit - so their spend is committed here
+       or never. `piped` is set by PrePoint, so its absence is the signal. *)
+    if getp p "piped" <> Bool true then begin
+      Hashtbl.remove pending ctx.c_id;
+      commit ctx p "_" "direct"
+    end;
+    (res, err) in
+
+  f.f_init <- (fun ctx opts ->
+      options := (match to_map opts with Map _ -> opts | _ -> empty_map ());
+      f.f_active <- opt_active opts;
+      if f.f_active then begin
+        Hashtbl.reset pending;
+        seq := 0;
+        ignore (record ctx);
+        let u = cu ctx in
+        let inner = u.u_fetcher in
+        u.u_fetcher <- (fun fctx url fd -> charge fctx url fd inner)
+      end);
+
+  f.f_hook <- (fun name ctx ->
+      if f.f_active then
+        match name with
+        | "PrePoint" ->
+          (* Mark the context as piped, so charge knows a PreDone is coming. *)
+          let p = pending_for ctx in
+          setp p "piped" (Bool true);
+          let lim = limit () in
+          if lim > 0. then begin
+            let rec_ = record ctx in
+            let spent = match getp (getp rec_ "total") "amount" with Num n -> n | _ -> 0. in
+            if spent >= lim then begin
+              setp (getp rec_ "budget") "exceeded" (Bool true);
+              if opt_str !options "onBudget" ~default:"warn" = "deny" then begin
+                let err = ctx_make_error ctx "cost_budget"
+                    ("Cost budget of " ^ js_string (Num lim) ^ " " ^ vstr_of (getp rec_ "currency")
+                     ^ " is spent (" ^ js_string (Num spent) ^ " used)") in
+                Hashtbl.replace ctx.c_out "point" (OErr err)
+              end
+            end
+          end
+        | "PreDone" -> finish ctx true
+        | _ -> ());
+  f
+
 (* ------------------------------------------------------------------ *)
 (* clienttrack                                                         *)
 (* ------------------------------------------------------------------ *)

package/project/.sdk/tm/ocaml/sdk_runtime.ml

@@ -345,7 +345,14 @@ let prepare_method_util (ctx : ctx) : string =
   | _ ->
     match ctx.c_op.op_name with
     | "create" -> "POST" | "update" -> "PUT" | "load" -> "GET"
-    | "list" -> "GET" | "remove" -> "DELETE" | "patch" -> "PATCH" | _ -> "GET"
+    | "list" -> "GET" | "remove" -> "DELETE" | "patch" -> "PATCH"
+    (* NO CATCH-ALL GET. The ts reference returns methodMap[key], which is
+     * undefined for an op the map does not name — the request is then rejected
+     * rather than silently issued. A `| _ -> "GET"` here turned every
+     * unrecognised op into a GET, which is both a divergence from the corpus
+     * (which expects no method for opname "bad") and the more dangerous of the
+     * two behaviours: a mistyped or unsupported op quietly fetched. *)
+    | _ -> ""
 
 let prepare_headers_util (ctx : ctx) : value =
   let options = client_options_map (cc ctx) in

package/project/.sdk/tm/ocaml/test/corpus_runner.ml

@@ -0,0 +1,185 @@
+(* Shared corpus harness for the ProjectName SDK.
+ *
+ * Extracted from struct_corpus.ml so the primary-utility suite can drive the
+ * SAME runner over test.json's "primary" section. OCaml runs a module's
+ * top-level effects on link, so a harness sitting beside a `let () = ...` main
+ * cannot be reused — linking it would run the struct corpus as a side effect.
+ * This module deliberately has no main.
+ *)
+
+(* Test runner for the shared JSON corpus (build/test/test.json).
+ * Self-contained: an in-tree JSON reader builds the library's `value` type
+ * directly, so the OCaml port is exercised exactly as in production. *)
+
+open Voxgig_struct
+
+let nullmark = "__NULL__"
+let undefmark = "__UNDEF__"
+let existsmark = "__EXISTS__"
+
+(* The JSON reader now lives in the runtime (sdk_json.ml) so the SDK's
+ * generated config can use it; the corpus runs against that same function
+ * rather than a second copy that could drift from it. *)
+let json_read = Sdk_json.json_read
+
+(* ---------------- fixJSON / equality ---------------- *)
+
+let rec fix_json v flag_null =
+  match v with
+  | Noval | Null -> if flag_null then Str nullmark else v
+  | Map m -> let o = empty_map () in
+    List.iter (fun (k, x) -> ignore (setprop o (Str k) (fix_json x flag_null))) m.entries; o
+  | List r -> lst (List.map (fun x -> fix_json x flag_null) !r)
+  | _ -> v
+
+(* Order-independent deep equality for maps; sequence equality for lists. *)
+let rec eqv a b =
+  match a, b with
+  | (Noval | Null), (Noval | Null) -> true
+  | Bool x, Bool y -> x = y
+  | Num x, Num y -> x = y
+  | Str x, Str y -> x = y
+  | List x, List y -> List.length !x = List.length !y && List.for_all2 eqv !x !y
+  | Map x, Map y ->
+    omap_len x = omap_len y &&
+    List.for_all (fun (k, v) -> match omap_get y k with Some w -> eqv v w | None -> false) x.entries
+  | _ -> a == b
+
+(* ---------------- match support ---------------- *)
+
+let matchval check base =
+  let check = if check = Str undefmark || check = Str nullmark then Noval else check in
+  if eqv check base then true
+  else match check with
+    | Str cs ->
+      let basestr = stringify base in
+      if String.length cs >= 2 && cs.[0] = '/' && cs.[String.length cs - 1] = '/' then
+        Vregex.test_str (String.sub cs 1 (String.length cs - 2)) basestr
+      else
+        let low s = String.lowercase_ascii s in
+        let contains hay needle =
+          let hl = String.length hay and nl = String.length needle in
+          let rec go i = if i + nl > hl then false
+            else if String.sub hay i nl = needle then true else go (i + 1) in
+          nl = 0 || go 0 in
+        contains (low basestr) (low (stringify check))
+    | Func _ -> true
+    | _ -> false
+
+let do_match check base =
+  let base = clone base in
+  ignore (walk ~before:(fun _k v _p path ->
+      (if not (isnode v) then begin
+          let baseval = getpath base path in
+          if eqv baseval v then ()
+          else if v = Str undefmark && is_nullish baseval then ()
+          else if v = Str existsmark && not (is_nullish baseval) then ()
+          else if not (matchval v baseval) then
+            raise (Struct_error (Printf.sprintf "MATCH: %s: [%s] <=> [%s]"
+                                   (String.concat "." (List.map js_string (match path with List r -> !r | _ -> [])))
+                                   (stringify v) (stringify baseval)))
+        end);
+      v) check)
+
+(* ---------------- result tracking ---------------- *)
+
+let npass = ref 0
+let nfail = ref 0
+let failures = ref []
+
+let record group name ok msg =
+  if ok then incr npass
+  else (incr nfail; failures := Printf.sprintf "FAIL %s %s - %s" group name msg :: !failures)
+
+(* ---------------- per-entry runner ---------------- *)
+
+let omap_v kvs =
+  let m = empty_map () in
+  List.iter (fun (k, v) -> ignore (setprop m (Str k) v)) kvs; m
+
+let getprop_raw_pub e k = (match e with Map m -> (match omap_get m k with Some x -> x | None -> Noval) | _ -> Noval)
+let entry_get e k = getprop_raw_pub e k
+let entry_has e k = match e with Map m -> omap_has m k | _ -> false
+let default_injdef_pub () =
+  { d_meta = Noval; d_extra = Noval; d_errs = Noval; d_modify = None; d_handler = None;
+    d_base = Noval; d_dparent = Noval; d_dpath = Noval; d_key = Noval }
+
+let resolve_args entry =
+  if entry_has entry "ctx" then [entry_get entry "ctx"]
+  else if entry_has entry "args" then (
+    match entry_get entry "args" with
+    | List r ->
+      (* ts's resolveArgs writes the live first arg back as entry.ctx, so a
+         `match: {ctx: ...}` resolves for args-style entries too. Without it
+         every such assertion reads null and asserts nothing. *)
+      (match !r with
+       | (Map _ as first) :: _ -> ignore (setprop entry (Str "ctx") first)
+       | _ -> ());
+      !r
+    | _ -> [])
+  else if entry_has entry "in" then [clone (entry_get entry "in")]
+  else [Noval]
+
+let check_result entry args res =
+  let matched = ref false in
+  (if entry_has entry "match" then begin
+      do_match (entry_get entry "match")
+        (omap_v ["in", entry_get entry "in"; "args", lst args;
+                 "out", entry_get entry "res"; "ctx", entry_get entry "ctx"]);
+      matched := true
+    end);
+  let out = entry_get entry "out" in
+  if eqv out res then ()
+  else if !matched && (out = Str nullmark || is_nullish out) then ()
+  else raise (Struct_error (Printf.sprintf "Expected: %s, got: %s" (stringify out) (stringify res)))
+
+let handle_error entry err =
+  let msg = (match err with Struct_error m -> m | e -> Printexc.to_string e) in
+  if entry_has entry "err" then begin
+    let entry_err = entry_get entry "err" in
+    if entry_err = Bool true || matchval entry_err (Str msg) then begin
+      if entry_has entry "match" then
+        do_match (entry_get entry "match")
+          (omap_v ["in", entry_get entry "in"; "out", entry_get entry "res";
+                   (* ts hands do_match the ERROR OBJECT, so a corpus
+                      `match: {err: {message: ...}}` resolves; a bare string
+                      leaves err.message reading null. *)
+                   "ctx", entry_get entry "ctx";
+                   "err", omap_v ["message", Str msg]])
+    end else
+      raise (Struct_error (Printf.sprintf "ERROR MATCH: [%s] <=> [%s]" (stringify entry_err) msg))
+  end else raise err
+
+let run_set ?(flags = []) group node subject =
+  let flag_null = (match List.assoc_opt "null" flags with Some b -> b | None -> true) in
+  let fixed = fix_json node flag_null in
+  let testset = (match getprop fixed (Str "set") with List r -> !r | _ -> []) in
+  List.iter (fun entry ->
+      let name = js_string (entry_get entry "name") in
+      try
+        (if not (entry_has entry "out") && flag_null then ignore (setprop entry (Str "out") (Str nullmark)));
+        let args = resolve_args entry in
+        let res = fix_json (subject args) flag_null in
+        ignore (setprop entry (Str "res") res);
+        check_result entry args res;
+        record group name true ""
+      with
+      | e ->
+        (try handle_error entry e; record group name true ""
+         with e2 -> record group name false
+                      (match e2 with Struct_error m -> m | _ -> Printexc.to_string e2)))
+    testset
+
+let run_single group node actual_fn =
+  try
+    let expected = getprop_raw_pub node "out" in
+    let actual = actual_fn (getprop_raw_pub node "in") in
+    if eqv expected actual then record group "single" true ""
+    else record group "single" false (Printf.sprintf "Expected: %s, got: %s" (stringify expected) (stringify actual))
+  with e -> record group "single" false (match e with Struct_error m -> m | _ -> Printexc.to_string e)
+
+(* ---------------- arg helpers ---------------- *)
+
+let arg1 f = fun args -> f (match args with x :: _ -> x | [] -> Noval)
+let vget vin k = match vin with Map m -> (match omap_get m k with Some x -> x | None -> Noval) | _ -> Noval
+let vhas vin k = match vin with Map m -> omap_has m k | _ -> false