@voxgig/sdkgen 4.3.0 → 4.4.0

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_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

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

@@ -0,0 +1,238 @@
+(* ProjectName SDK primary-utility corpus.
+ *
+ * Drives the SHARED language-neutral corpus (.sdk/test/test.json -> "primary")
+ * through this SDK's request-shaping utilities, so the cases cannot drift from
+ * the reference implementation. Each section is looked up with getSpec and
+ * executed with runset, as the ts/js reference harness does.
+ *
+ * ocaml had NO primary-utility suite at all before this: its request-shaping
+ * utilities were unverified in every language-neutral sense. The harness is
+ * Corpus_runner, shared with the struct corpus.
+ *)
+
+open Voxgig_struct
+open Sdk_types
+open Sdk_helpers
+open Sdk_runtime
+open Corpus_runner
+
+let client () : sdk_client = Sdk_client.test ()
+
+(* A client built from a section's DEF.setup.a block. prepare_auth reads the
+ * CLIENT's options, as the ts reference does via client.options(), so a
+ * section's setup cannot reach it through ctx.options. *)
+let client_for primary name =
+  let setup =
+    List.fold_left (fun acc k -> getprop_raw_pub acc k) primary [name; "DEF"; "setup"; "a"]
+  in
+  match setup with
+  | Map _ -> Sdk_client.test_with Noval setup
+  | _ -> Sdk_client.test ()
+
+let getspec root path =
+  List.fold_left (fun acc k -> getprop_raw_pub acc k) root path
+
+(* A LIVE context from a corpus map. The utilities read and MUTATE spec,
+ * result and response through their record types, so a bare value map leaves
+ * them nothing to work on and every match reads null. *)
+let ctx_from (cl : sdk_client) (ctxmap : value) : ctx =
+  let u = cl.cl_utility in
+  (* The corpus names the op — {"ctx": {"opname": "create"}} — and
+   * prepare_method reads it. Hardcoding "load" made every method GET. *)
+  (* Only when the corpus names one. Defaulting to "load" made the SDK report
+   * the wrong operation in error messages the corpus matches on — it expects
+   * "unknown operation" where no op is named. *)
+  let cs =
+    match getprop_raw_pub ctxmap "opname" with
+    | Str s -> { (default_ctxspec ()) with cs_opname = Some s }
+    | _ -> default_ctxspec ()
+  in
+  let c = u.u_make_context cs cl.cl_rootctx in
+  (match getprop_raw_pub ctxmap "spec" with
+   | Map _ as m -> c.c_spec <- Some (new_spec m)
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "result" with
+   | Map _ as m ->
+     let rt = new_result m in
+     (* new_result hardcodes rt_err = None, so a corpus result carrying an err
+      * arrives empty and result_basic has no previous message to prepend —
+      * it produced "request: 400: BAD" where the contract says
+      * "Foo: request: 400: BAD". The lua and elixir drivers build it too. *)
+     (match getprop_raw_pub m "err" with
+      | Map _ as em ->
+        (match getprop_raw_pub em "message" with
+         | Str msg when msg <> "" ->
+           rt.rt_err <- Some { err_code = ""; err_msg = msg; err_result = Noval; err_spec = Noval }
+         | _ -> ())
+      | _ -> ());
+     c.c_result <- Some rt
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "response" with
+   | Map _ as m ->
+     let r = new_response m in
+     (* result_body_util reads response.json and requires it to be CALLABLE;
+      * the corpus supplies a plain `body`, so wrap it, as the lua and elixir
+      * drivers do. Without this every ctx.result.body match reads empty. *)
+     (match getprop_raw_pub m "body" with
+      | Noval -> ()
+      | b -> r.rs_json <- Func (fun _ _ _ _ -> b));
+     (* Header names arrive from the wire in any case and the contract is
+      * lowercase; the lua and elixir drivers normalise here rather than in
+      * result_headers_util, which copies them verbatim. *)
+     (match getprop_raw_pub m "headers" with
+      | Map hm ->
+        let low = empty_map () in
+        List.iter (fun (k, v) -> ignore (setprop low (Str (String.lowercase_ascii k)) v))
+          hm.entries;
+        r.rs_headers <- low
+      | _ -> ());
+     c.c_response <- Some r
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "point" with
+   | Map _ as m -> c.c_point <- m
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "reqdata" with Noval -> () | v -> c.c_reqdata <- v);
+  (match getprop_raw_pub ctxmap "reqmatch" with Noval -> () | v -> c.c_reqmatch <- v);
+  (match getprop_raw_pub ctxmap "data" with Noval -> () | v -> c.c_data <- v);
+  (match getprop_raw_pub ctxmap "match" with Noval -> () | v -> c.c_match <- v);
+  c
+
+(* The corpus speaks camelCase; this port stores rs_status_text / rt_ok. A
+ * neutral-named view is what the match assertions read. *)
+let result_value (r : result option) : value =
+  match r with
+  | None -> Noval
+  | Some rt -> result_to_value rt
+
+let ctx_arg args = match args with x :: _ -> x | [] -> Noval
+
+(* The harness reports a non-Struct_error exception via Printexc, which renders
+ * a branded SDK error as "Sdk_types.Sdk_error_exc(_)" and loses the message the
+ * corpus matches on. Convert here rather than teaching the shared harness about
+ * SDK types — corpus_runner is struct's, not this SDK's. *)
+let run_guarded f c =
+  try f c with
+  | Sdk_error_exc e -> raise (Struct_error e.err_msg)
+
+(* Publish the MUTATED ctx back onto the corpus map the match reads.
+ * check_result matches against entry.ctx, which is the raw corpus map; the
+ * utilities mutate the live records beside it, so without this every
+ * `match: ctx.spec.*` / `ctx.result.*` assertion reads empty. Neutral names,
+ * because the corpus is camelCase and this port stores rs_status_text/rt_ok. *)
+let publish (ctxmap : value) (c : ctx) =
+  (match c.c_spec with
+   | Some sp -> ignore (setprop ctxmap (Str "spec") (spec_to_value sp))
+   | None -> ());
+  (match c.c_result with
+   | Some _ -> ignore (setprop ctxmap (Str "result") (result_value c.c_result))
+   | None -> ());
+  (match c.c_response with
+   | Some _ -> ignore (setprop ctxmap (Str "response") (Str "__EXISTS__"))
+   | None -> ());
+  ()
+
+let () =
+  let testfile = if Array.length Sys.argv > 1 then Sys.argv.(1) else "../.sdk/test/test.json" in
+  let ic = open_in_bin testfile in
+  let len = in_channel_length ic in
+  let raw = really_input_string ic len in
+  close_in ic;
+  let alltests = json_read raw in
+  let primary = getprop_raw_pub alltests "primary" in
+
+  let cl = client () in
+  let u = cl.cl_utility in
+
+  (* Sections configured by their own DEF.setup block get their own client. *)
+  let ctx_section_with cl2 primary name f =
+    run_set name (getspec primary [name; "basic"])
+      (fun args ->
+         let ctxmap = ctx_arg args in
+         let c = ctx_from cl2 ctxmap in
+         let out = run_guarded f c in
+         publish ctxmap c;
+         out)
+  in
+
+  let ctx_section primary name f =
+    run_set name (getspec primary [name; "basic"])
+      (fun args ->
+         let ctxmap = ctx_arg args in
+         let c = ctx_from cl ctxmap in
+         let out = run_guarded f c in
+         publish ctxmap c;
+         out)
+  in
+
+  ctx_section primary "done" (fun c -> u.u_done c);
+  ctx_section primary "makeUrl" (fun c -> match make_url_util c with (s, _) -> Str s);
+  ctx_section primary "makeRequest"
+    (fun c -> ignore (make_request_util c); result_value c.c_result);
+  ctx_section primary "makeResponse"
+    (fun c -> ignore (make_response_util c); result_value c.c_result);
+  ctx_section_with (client_for primary "makeSpec") primary "makeSpec"
+    (fun c -> match make_spec_util c with
+       | (Some s, _) -> spec_to_value s | _ -> Noval);
+  ctx_section_with (client_for primary "prepareAuth") primary "prepareAuth"
+    (fun c -> ignore (prepare_auth_util c);
+      match c.c_spec with Some s -> spec_to_value s | None -> Noval);
+  ctx_section primary "prepareBody" (fun c -> prepare_body_util c);
+  ctx_section primary "prepareHeaders" (fun c -> prepare_headers_util c);
+  ctx_section primary "prepareMethod"
+    (fun c -> match prepare_method_util c with "" -> Noval | m -> Str m);
+  ctx_section primary "prepareParams" (fun c -> prepare_params_util c);
+  ctx_section primary "preparePath" (fun c -> Str (prepare_path_util c));
+  ctx_section primary "prepareQuery" (fun c -> prepare_query_util c);
+  ctx_section primary "resultBasic" (fun c -> result_basic_util c; result_value c.c_result);
+  ctx_section primary "resultBody" (fun c -> result_body_util c; result_value c.c_result);
+  ctx_section primary "resultHeaders" (fun c -> result_headers_util c; result_value c.c_result);
+  ctx_section primary "transformRequest" (fun c -> transform_request_util c);
+  ctx_section primary "transformResponse" (fun c -> transform_response_util c);
+
+  (* Sections that take a bare map or explicit args rather than a ctx. *)
+  let arg_section primary name f =
+    run_set name (getspec primary [name; "basic"]) (fun args -> run_guarded f args)
+  in
+
+  arg_section primary "makeContext" (fun args ->
+      let inv = ctx_arg args in
+      let c = ctx_from cl inv in
+      jo [("op", jo [("entity", Str c.c_op.op_entity); ("name", Str c.c_op.op_name);
+                     ("input", Str c.c_op.op_input); ("points", c.c_op.op_points)])]);
+
+  arg_section primary "makeOptions" (fun args ->
+      let inv = ctx_arg args in
+      let c = ctx_from cl (jo []) in
+      c.c_config <- getprop_raw_pub inv "config";
+      c.c_options <- getprop_raw_pub inv "options";
+      make_options_util c);
+
+  arg_section primary "makeError" (fun args ->
+      let a0 = ctx_arg args in
+      let a1 = (match args with _ :: y :: _ -> y | _ -> Noval) in
+      let c = ctx_from cl a0 in
+      let msg = (match getprop_raw_pub a1 "message" with Str m -> m | _ -> "") in
+      let e = { err_code = ""; err_msg = msg; err_result = Noval; err_spec = Noval } in
+      let out = make_error_util c (if msg = "" then None else Some e) in
+      publish a0 c;
+      out);
+
+  arg_section primary "operator" (fun args ->
+      let inv = ctx_arg args in
+      let op = new_operation inv in
+      jo [("entity", Str op.op_entity); ("input", Str op.op_input);
+          ("name", Str op.op_name); ("points", op.op_points)]);
+
+  arg_section primary "param" (fun args ->
+      let a0 = ctx_arg args in
+      let a1 = (match args with _ :: y :: _ -> y | _ -> Noval) in
+      let c = ctx_from cl a0 in
+      let out = param_util c a1 in
+      publish a0 c;
+      out);
+
+  List.iter print_endline (List.rev !failures);
+  Printf.printf "\nPRIMARY CORPUS: PASS %d  FAIL %d\n" !npass !nfail;
+  (* A run that executes nothing is not a pass. *)
+  if !npass = 0 then (print_endline "the primary corpus executed no cases"; exit 1);
+  if !nfail > 0 then exit 1