@voxgig/sdkgen 4.3.0 → 4.4.0

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

@@ -1,165 +1,10 @@
-(* 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. *)
+(* Struct corpus: drives test.json -> "struct" through the vendored
+ * Voxgig_struct implementation. The harness itself lives in Corpus_runner so
+ * the primary-utility suite can share it.
+ *)
 
 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 -> !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";
-                   "ctx", entry_get entry "ctx"; "err", 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
+open Corpus_runner
 
 (* ---------------- test groups ---------------- *)
 

package/project/.sdk/tm/scala/Makefile

@@ -12,6 +12,7 @@ test:
 	scala-cli run . --main-class SdkTestMain
 	scala-cli run . --main-class SdkEntityTestMain
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json
+	scala-cli run . --main-class PrimaryCorpusMain -- ../.sdk/test/test.json
 
 corpus:
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json

package/project/.sdk/tm/scala/sdktest/PrimaryCorpus.scala

@@ -0,0 +1,294 @@
+// Primary-utility corpus driver.
+//
+// Drives every `primary` section of the shared corpus (../.sdk/test/test.json)
+// through this SDK's utilities, the way the ts reference harness does. The
+// match/args/err machinery is reused from Runner (StructCorpus.scala); what
+// this file adds is the bridge between the corpus Value ADT and the SDK's
+// Java-collection world, plus a live Context built from each corpus entry.
+
+import voxgig.struct.{clone as sclone, *}
+import SCALAPACKAGE.core.*
+
+import java.util.{ArrayList, LinkedHashMap, List as JList, Map as JMap}
+import scala.collection.mutable.{ArrayBuffer, LinkedHashMap as MLinkedHashMap}
+import scala.jdk.CollectionConverters.*
+
+object PrimaryCorpus {
+
+  // ---- Value <-> Java bridge ---------------------------------------------
+
+  def toJava(v: Value): Object = v match {
+    case VMap(m) =>
+      val out = new LinkedHashMap[String, Object]()
+      m.foreach { case (k, x) => out.put(k, toJava(x)) }
+      out
+    case VList(b) =>
+      val out = new ArrayList[Object]()
+      b.foreach { x => out.add(toJava(x)) }
+      out
+    case VStr(s)  => s
+    case VBool(b) => java.lang.Boolean.valueOf(b)
+    case VNum(n)  =>
+      // The corpus writes whole numbers as JSON integers; handing the SDK a
+      // Double turned "1" into "1.0" everywhere it reached a URL or header.
+      if (n == Math.floor(n) && !n.isInfinite) java.lang.Long.valueOf(n.toLong)
+      else java.lang.Double.valueOf(n)
+    case _ => null
+  }
+
+  def toValue(o: Object): Value = o match {
+    case null => VNull
+    // Struct.UNDEF is the library's "no value" sentinel, not a value: an
+    // unresolved transform path returns it, and without this it reached the
+    // corpus as the string "java.lang.Object@..." instead of null.
+    case x if x eq SCALAPACKAGE.utility.struct.Struct.UNDEF => VNull
+    case m: JMap[_, _] =>
+      val out = MLinkedHashMap.empty[String, Value]
+      m.asInstanceOf[JMap[String, Object]].asScala.foreach { case (k, x) => out.put(k, toValue(x)) }
+      VMap(out)
+    case l: JList[_] =>
+      val out = ArrayBuffer.empty[Value]
+      l.asInstanceOf[JList[Object]].asScala.foreach { x => out += toValue(x) }
+      VList(out)
+    case s: String            => VStr(s)
+    case b: java.lang.Boolean => VBool(b.booleanValue())
+    case n: java.lang.Number  => VNum(n.doubleValue())
+    case e: RuntimeException  =>
+      val m = MLinkedHashMap.empty[String, Value]
+      m.put("message", VStr(String.valueOf(e.getMessage)))
+      VMap(m)
+    case x => VStr(String.valueOf(x))
+  }
+
+  private def jmap(v: Value): JMap[String, Object] = toJava(v) match {
+    case m: JMap[_, _] => m.asInstanceOf[JMap[String, Object]]
+    case _             => new LinkedHashMap[String, Object]()
+  }
+
+  private def vget(v: Value, k: String): Value = v match {
+    case VMap(m) => m.getOrElse(k, Noval)
+    case _       => Noval
+  }
+
+  // ---- corpus access -----------------------------------------------------
+
+  private var CORPUS: Value = Noval
+
+  private def sectionBasic(name: String): Value = vget(vget(vget(CORPUS, "primary"), name), "basic")
+
+  // makeSpec and prepareAuth read defaults off the CLIENT, as the ts reference
+  // does via client.options(), so a section's DEF.setup cannot reach them
+  // through ctx.options — those sections get their own client.
+  private def sectionSetup(name: String): Value =
+    vget(vget(vget(vget(vget(CORPUS, "primary"), name), "DEF"), "setup"), "a")
+
+  // ---- live context from a corpus map ------------------------------------
+
+  private def corpusCtx(client: ProjectNameSDK, ctxmap: Value): Context = {
+    val utility = client.getUtility()
+    val cm = new LinkedHashMap[String, Object]()
+    // Only when the corpus names one: defaulting to "load" made the SDK report
+    // the wrong operation in the error messages the corpus matches on.
+    vget(ctxmap, "opname") match {
+      case VStr(s) => cm.put("opname", s)
+      case _       =>
+    }
+    val ctx = utility.makeContext(cm, client.getRootCtx())
+
+    vget(ctxmap, "spec") match {
+      case m @ VMap(_) => ctx.spec = new Spec(jmap(m))
+      case _           =>
+    }
+
+    vget(ctxmap, "result") match {
+      case m @ VMap(_) =>
+        val r = new Result(jmap(m))
+        // Result does not carry an err in from the map, so a corpus result
+        // holding one arrived empty and resultBasic had no previous message
+        // to prepend.
+        vget(vget(m, "err"), "message") match {
+          case VStr(msg) if msg.nonEmpty => r.err = new SdkError("", msg, null)
+          case _                         =>
+        }
+        ctx.result = r
+      case _ =>
+    }
+
+    vget(ctxmap, "response") match {
+      case m @ VMap(_) =>
+        val resp = new Response(jmap(m))
+        // resultBody reads response.json and requires it to be CALLABLE; the
+        // corpus supplies a plain `body`.
+        vget(m, "body") match {
+          case Noval => ()
+          case b =>
+            val bj = toJava(b)
+            resp.body = bj
+            resp.jsonFunc = new java.util.function.Supplier[Object] { def get(): Object = bj }
+        }
+        // Header names arrive from the wire in any case and the contract is
+        // lowercase; resultHeaders copies them verbatim.
+        vget(m, "headers") match {
+          case VMap(hm) =>
+            val low = new LinkedHashMap[String, Object]()
+            hm.foreach { case (k, x) => low.put(k.toLowerCase, toJava(x)) }
+            resp.headers = low
+          case _ =>
+        }
+        ctx.response = resp
+      case _ =>
+    }
+
+    vget(ctxmap, "point") match { case m @ VMap(_) => ctx.point = jmap(m); case _ => }
+    vget(ctxmap, "reqdata") match { case Noval => (); case v => ctx.reqdata = jmap(v) }
+    vget(ctxmap, "reqmatch") match { case Noval => (); case v => ctx.reqmatch = jmap(v) }
+    vget(ctxmap, "data") match { case Noval => (); case v => ctx.data = jmap(v) }
+    vget(ctxmap, "match") match { case Noval => (); case v => ctx.matchData = jmap(v) }
+    vget(ctxmap, "options") match { case m @ VMap(_) => ctx.options = jmap(m); case _ => }
+    vget(ctxmap, "config") match { case m @ VMap(_) => ctx.config = jmap(m); case _ => }
+    ctx
+  }
+
+  // The match reads the corpus map while the utilities mutate the live objects
+  // hanging off the context, so without this every ctx.* assertion reads null.
+  private def publishCtx(ctxmap: Value, ctx: Context): Unit = ctxmap match {
+    case VMap(m) =>
+      if (ctx.spec != null) m.put("spec", specValue(ctx.spec))
+      if (ctx.result != null) m.put("result", resultValue(ctx.result))
+      if (ctx.response != null) m.put("response", VStr(Runner.EXISTSMARK))
+    case _ =>
+  }
+
+  private def specValue(s: Spec): Value = {
+    val m = MLinkedHashMap.empty[String, Value]
+    m.put("base", VStr(s.base)); m.put("prefix", VStr(s.prefix)); m.put("suffix", VStr(s.suffix))
+    m.put("path", VStr(s.path)); m.put("url", VStr(s.url)); m.put("step", VStr(s.step))
+    m.put("method", VStr(s.method))
+    m.put("headers", toValue(s.headers)); m.put("params", toValue(s.params))
+    m.put("query", toValue(s.query)); m.put("alias", toValue(s.alias))
+    if (s.parts != null) m.put("parts", toValue(s.parts))
+    if (s.body != null) m.put("body", toValue(s.body))
+    VMap(m)
+  }
+
+  private def resultValue(r: Result): Value = {
+    val m = MLinkedHashMap.empty[String, Value]
+    m.put("ok", VBool(r.ok)); m.put("status", VNum(r.status.toDouble))
+    m.put("statusText", VStr(r.statusText))
+    m.put("headers", toValue(r.headers))
+    if (r.body != null) m.put("body", toValue(r.body))
+    if (r.resdata != null) m.put("resdata", toValue(r.resdata))
+    if (r.resmatch != null) m.put("resmatch", toValue(r.resmatch))
+    if (r.err != null) {
+      val e = MLinkedHashMap.empty[String, Value]
+      e.put("message", VStr(String.valueOf(r.err.getMessage)))
+      m.put("err", VMap(e))
+    }
+    VMap(m)
+  }
+
+  // ---- section runners ---------------------------------------------------
+
+  private def argAt(args: Seq[Value], i: Int): Value = if (i < args.length) args(i) else Noval
+
+  // A section driven with a ctx built from the corpus entry.
+  private def runset(name: String, client: ProjectNameSDK)(f: (Context, Seq[Value]) => Value): Unit =
+    Runner.runSet(name, sectionBasic(name), (args: Seq[Value]) => {
+      val ctxmap = argAt(args, 0)
+      val ctx = corpusCtx(client, ctxmap)
+      val out = f(ctx, args)
+      publishCtx(ctxmap, ctx)
+      out
+    })
+
+  // A section that takes a bare map or explicit args rather than a ctx.
+  private def runsetArgs(name: String)(f: Seq[Value] => Value): Unit =
+    Runner.runSet(name, sectionBasic(name), f)
+
+  private def clientFor(name: String, shared: ProjectNameSDK): ProjectNameSDK =
+    sectionSetup(name) match {
+      case m @ VMap(_) => ProjectNameSDK.testSDK(null, jmap(m))
+      case _           => shared
+    }
+
+  def run(testfile: String): Int = {
+    val src = new String(java.nio.file.Files.readAllBytes(java.nio.file.Paths.get(testfile)), "UTF-8")
+    CORPUS = Runner.jsonRead(src)
+
+    val sdk = ProjectNameSDK.testSDK()
+    val u = sdk.getUtility()
+
+    runset("done", sdk) { (c, _) => toValue(u.done(c)) }
+    runset("makeUrl", sdk) { (c, _) => toValue(u.makeUrl(c)) }
+    runset("makeRequest", sdk) { (c, _) => u.makeRequest(c); resultValue(c.result) }
+    runset("makeResponse", sdk) { (c, _) => u.makeResponse(c); resultValue(c.result) }
+    runset("makeSpec", clientFor("makeSpec", sdk)) { (c, _) =>
+      val s = u.makeSpec(c); if (s != null) c.spec = s; specValue(c.spec)
+    }
+    runset("prepareAuth", clientFor("prepareAuth", sdk)) { (c, _) =>
+      u.prepareAuth(c); specValue(c.spec)
+    }
+    runset("prepareBody", sdk) { (c, _) => toValue(u.prepareBody(c)) }
+    runset("prepareHeaders", sdk) { (c, _) => toValue(u.prepareHeaders(c)) }
+    runset("prepareMethod", sdk) { (c, _) =>
+      val m = u.prepareMethod(c); if (m == null || m.isEmpty) VNull else VStr(m)
+    }
+    runset("prepareParams", sdk) { (c, _) => toValue(u.prepareParams(c)) }
+    runset("preparePath", sdk) { (c, _) => toValue(u.preparePath(c)) }
+    runset("prepareQuery", sdk) { (c, _) => toValue(u.prepareQuery(c)) }
+    runset("resultBasic", sdk) { (c, _) =>
+      val r = u.resultBasic(c); if (r != null) c.result = r; resultValue(c.result)
+    }
+    runset("resultBody", sdk) { (c, _) =>
+      val r = u.resultBody(c); if (r != null) c.result = r; resultValue(c.result)
+    }
+    runset("resultHeaders", sdk) { (c, _) =>
+      val r = u.resultHeaders(c); if (r != null) c.result = r; resultValue(c.result)
+    }
+    runset("transformRequest", sdk) { (c, _) => toValue(u.transformRequest(c)) }
+    runset("transformResponse", sdk) { (c, _) => toValue(u.transformResponse(c)) }
+    runset("param", sdk) { (c, args) => toValue(u.param(c, toJava(argAt(args, 1)))) }
+    runset("makeError", sdk) { (c, args) =>
+      val msg = vget(argAt(args, 1), "message") match { case VStr(s) => s; case _ => "" }
+      val in = if (msg.isEmpty) null else new SdkError("", msg, null)
+      toValue(u.makeError(c, in))
+    }
+
+    runsetArgs("makeContext") { args =>
+      val c = corpusCtx(sdk, argAt(args, 0))
+      val op = MLinkedHashMap.empty[String, Value]
+      if (c.op != null) {
+        op.put("entity", VStr(c.op.entity)); op.put("name", VStr(c.op.name))
+        op.put("input", VStr(c.op.input)); op.put("points", toValue(c.op.points))
+      }
+      val out = MLinkedHashMap.empty[String, Value]
+      out.put("op", VMap(op))
+      VMap(out)
+    }
+    runsetArgs("makeOptions") { args =>
+      val in = argAt(args, 0)
+      val c = corpusCtx(sdk, VMap(MLinkedHashMap.empty[String, Value]))
+      vget(in, "config") match { case Noval => (); case v => c.config = jmap(v) }
+      vget(in, "options") match { case Noval => (); case v => c.options = jmap(v) }
+      toValue(u.makeOptions(c))
+    }
+    runsetArgs("operator") { args =>
+      val in = argAt(args, 0)
+      val m = MLinkedHashMap.empty[String, Value]
+      m.put("entity", vget(in, "entity") match { case Noval => VStr("_"); case v => v })
+      m.put("input", vget(in, "input") match { case Noval => VStr("_"); case v => v })
+      m.put("name", vget(in, "name") match { case Noval => VStr("_"); case v => v })
+      m.put("points", vget(in, "points") match { case l @ VList(_) => l; case _ => VList(ArrayBuffer.empty[Value]) })
+      VMap(m)
+    }
+
+    Runner.reportPrimary()
+  }
+}
+
+object PrimaryCorpusMain {
+  def main(args: Array[String]): Unit = {
+    val testfile = if (args.length > 0) args(0) else "../.sdk/test/test.json"
+    System.exit(PrimaryCorpus.run(testfile))
+  }
+}

package/project/.sdk/tm/scala/utility/Make.scala

@@ -199,13 +199,60 @@ object MakePoint {
 }
 
 object MakeOptions {
+
+  /**
+   * 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.
+   *
+   * Scala `var` fields compile to a private field plus accessors, so the
+   * lookup is on the declared field and needs setAccessible. Function types
+   * erase on the JVM, so isInstance checks the FunctionN arity rather than the
+   * full signature - the same limit java's port documents.
+   *
+   * 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.
+   */
+  def overrideUtil(utility: Utility, key: String, value: Object): Boolean = {
+    if (null == key || key.isEmpty || key.contains("_") || "custom" == key) return false
+    if (null == value) return false
+
+    try {
+      val field = classOf[Utility].getDeclaredField(key)
+      if (!field.getType.isInstance(value)) return false
+      field.setAccessible(true)
+      field.set(utility, value)
+      true
+    }
+    catch {
+      case _: NoSuchFieldException => false
+    }
+  }
+
   def makeOptions(ctx: Context): JMap[String, Object] = {
     var options = ctx.options
     if (options == null) options = new LinkedHashMap[String, Object]()
 
-    // Merge custom utility overrides onto the utility object.
+    // 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 map
+    // nothing reads - made `utility -> Map("fetcher" -> ...)`, the documented
+    // transport seam, a silent no-op here while ts honoured it.
     val customUtils = Helpers.toMapAny(options.get("utility"))
-    if (customUtils != null && ctx.utility != null) ctx.utility.custom.putAll(customUtils)
+    if (customUtils != null && ctx.utility != null) {
+      customUtils.entrySet().forEach { e =>
+        if (!overrideUtil(ctx.utility, e.getKey, e.getValue))
+          ctx.utility.custom.put(e.getKey, e.getValue)
+      }
+    }
 
     var opts = Struct.clone(options).asInstanceOf[JMap[String, Object]]
 

package/project/.sdk/tm/scala/utility/Prepare.scala

@@ -26,7 +26,9 @@ object PrepareMethod {
       case "list" => "GET"
       case "remove" => "DELETE"
       case "patch" => "PATCH"
-      case _ => "GET"
+      // No GET catch-all: an unrecognised op must fall through to the
+      // allow.method gate, not be silently issued as a GET.
+      case _ => ""
     }
   }
 }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/MakeOptions.swift

@@ -57,12 +57,30 @@ private func buildOptSpec() -> Value {
 func makeOptionsUtil(_ ctx: Context) -> VMap {
   let options = ctx.options ?? VMap()
 
-  // Merge custom utility overrides onto the utility object. Read from the
-  // original options before clone for safety.
+  // Merge utility overrides from options onto the utility object. Read from
+  // the original options before clone for safety.
+  //
+  // `fetcher` REPLACES the member; every other key is attached as a custom
+  // extra. Shelving the fetcher too made `utility: ["fetcher": ...]`, the
+  // documented transport seam, a silent no-op here while ts honoured it - and
+  // it is the seam the shared feature corpus scripts.
+  //
+  // PARTIAL, DELIBERATELY. The other members are replaceable in principle -
+  // Value.native carries any Swift value - but each has a distinct closure
+  // type, so honouring them means one `as?` arm per member with the signature
+  // written exactly. `fetcher` is the documented seam and the one the corpus
+  // needs; the rest stay in `custom` until a swift toolchain can compile the
+  // arms rather than have them written blind. See AGENTS.md.
   if let customUtils = gp(options, "utility").asMap {
     if let utility = ctx.utility {
       for (k, v) in customUtils.entries {
-        utility.custom[k] = v.asNative ?? v
+        let native = v.asNative ?? v
+        if "fetcher" == k, let fn = native as? FetcherFunc {
+          utility.fetcher = fn
+        }
+        else {
+          utility.custom[k] = native
+        }
       }
     }
   }

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -30,8 +30,19 @@ function ownIdField(config: any, getpath: any, entityName: string): string {
       if (ptterm !== bestterm ? ptterm : pt.parts.length < best.parts.length) best = pt
     }
     const parts: string[] = (best && best.parts) || []
-    const last = [...parts].reverse().find((p: string) => p.startsWith('{'))
-    if (null != last) return last.slice(1, -1)
+    // THE LAST PART, not the last param anywhere in the path. A record route
+    // ENDS in its key: /orgs/{org}/private-registries/{secret_name} does,
+    // /orgs/{org}/private-registries/public-key does not. Reading the last
+    // param wherever it fell returned `{org}` for that second path — a PARENT
+    // reference — and the seeding walk then stamped the record's own key over
+    // org_id, destroying the ORG01 the fixture set and the test looks up from
+    // idmap. github's private_registry failed its update with a 404 that named
+    // nothing to do with orgs.
+    //
+    // A point that does not end in a param says nothing about this entity's
+    // key, so move on to the next op rather than guess from it.
+    const lastPart = 0 < parts.length ? String(parts[parts.length - 1]) : ''
+    if (lastPart.startsWith('{')) return lastPart.slice(1, -1)
   }
   return 'id'
 }

package/project/.sdk/tm/zig/core/utility.zig

@@ -1019,7 +1019,14 @@ pub fn prepare_method_util(ctx: *Context) []const u8 {
     if (std.mem.eql(u8, opname, "list")) return "GET";
     if (std.mem.eql(u8, opname, "remove")) return "DELETE";
     if (std.mem.eql(u8, opname, "patch")) return "PATCH";
-    return "GET";
+
+    // NO CATCH-ALL GET. The ts reference returns methodMap[key], which is
+    // undefined for an op the map does not name, so the request is refused
+    // rather than issued. Returning "GET" here made every unrecognised op a
+    // GET — a mistyped or unsupported op quietly fetched — and the method
+    // feeds the allow.method gate, so it is not cosmetic. ocaml had the same
+    // fallback; the shared corpus caught both.
+    return "";
 }
 
 pub fn prepare_headers_util(ctx: *Context) Value {