@voxgig/sdkgen 4.34.1 → 4.34.2

package/project/.sdk/tm/kotlin/test/ConcurrencyTest.kt

@@ -0,0 +1,193 @@
+package KOTLINPACKAGE.sdktest
+
+// Requests in flight at once on one client. Each resolves its operation
+// through the cache the client's root context shares with every request, and
+// registers and cleans secrets through the one registry the client holds.
+
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.CyclicBarrier
+import java.util.function.BiFunction
+import java.util.function.Supplier
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertSame
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+import KOTLINPACKAGE.core.Context
+import KOTLINPACKAGE.core.Operation
+import KOTLINPACKAGE.core.ProjectNameSDK
+import KOTLINPACKAGE.core.Utility
+
+class ConcurrencyTest {
+
+  private val rounds = 200
+  private val width = 8
+  private val ops = 32
+
+  // A live client whose transport answers at once.
+  private fun liveClient(): ProjectNameSDK {
+    val fetch = BiFunction<String, MutableMap<String, Any?>, MutableMap<String, Any?>> { _, _ ->
+      linkedMapOf<String, Any?>(
+        "status" to 200,
+        "statusText" to "OK",
+        "headers" to linkedMapOf<String, Any?>(),
+        "json" to Supplier<Any?> { linkedMapOf<String, Any?>("ok" to true) },
+      )
+    }
+    return ProjectNameSDK(linkedMapOf<String, Any?>(
+      "base" to "http://concurrency.test/api",
+      "allow" to linkedMapOf<String, Any?>("op" to "direct"),
+      "system" to linkedMapOf<String, Any?>("fetch" to fetch),
+    ))
+  }
+
+  // Runs body on `width` threads released together, and returns what they threw.
+  private fun atOnce(body: (Int) -> Unit): List<Throwable> {
+    val start = CyclicBarrier(width)
+    val thrown = ConcurrentLinkedQueue<Throwable>()
+    val threads = (0 until width).map { n ->
+      Thread {
+        try {
+          start.await()
+          body(n)
+        } catch (t: Throwable) {
+          thrown.add(t)
+        }
+      }.also { it.start() }
+    }
+    threads.forEach { it.join() }
+    return thrown.toList()
+  }
+
+  @Test
+  fun concurrentFirstRequestsSucceed() {
+    repeat(rounds) { round ->
+      // A fresh client each round, so every request in it is a first request.
+      val client = liveClient()
+      val results = arrayOfNulls<MutableMap<String, Any?>>(width)
+      val thrown = atOnce { n -> results[n] = client.direct(linkedMapOf<String, Any?>("path" to "p$n")) }
+
+      assertTrue(thrown.isEmpty(), "round $round threw: $thrown")
+      results.forEachIndexed { n, res ->
+        assertEquals(true, res?.get("ok"), "round $round, request $n failed: $res")
+      }
+    }
+  }
+
+  @Test
+  fun concurrentResolutionsShareOneCachedOperation() {
+    repeat(rounds) { round ->
+      val client = liveClient()
+      val utility = client.getUtility()
+      val root = client.getRootCtx()
+      val got = Array(width) { arrayOfNulls<Operation>(ops) }
+      val thrown = atOnce { n ->
+        for (k in 0 until ops) {
+          got[n][k] = utility.makeContext(linkedMapOf<String, Any?>("opname" to "op$k"), root).op
+        }
+      }
+
+      assertTrue(thrown.isEmpty(), "round $round threw: $thrown")
+      for (k in 0 until ops) {
+        val cached = utility.makeContext(linkedMapOf<String, Any?>("opname" to "op$k"), root).op
+        for (n in 0 until width) {
+          assertSame(cached, got[n][k], "round $round: op$k resolved to more than one Operation")
+        }
+      }
+    }
+  }
+
+  private fun addedSecret(round: Int, n: Int, k: Int) = "ADDED-SECRET-$round-$n-$k"
+
+  // Registers thread n's secrets, then counts the thread out of registering.
+  private fun registerSecrets(
+    utility: Utility, root: Context, round: Int, n: Int, registering: CountDownLatch,
+  ) {
+    try {
+      for (k in 0 until ops) {
+        utility.cleanAdd(root, addedSecret(round, n, k))
+      }
+    } finally {
+      registering.countDown()
+    }
+  }
+
+  private fun assertEverySecretMasked(utility: Utility, root: Context, round: Int) {
+    for (n in 0 until width / 2) {
+      for (k in 0 until ops) {
+        val added = addedSecret(round, n, k)
+        assertEquals("[redacted]", utility.clean(root, added),
+          "round $round: $added was registered but not masked")
+      }
+    }
+  }
+
+  // Secrets registered on some threads while others clean: every clean masks
+  // what was registered before it, the longer secret whole, and no
+  // registration is lost.
+  @Test
+  fun concurrentRegistrationKeepsEverySecretMasked() {
+    repeat(rounds / 4) { round ->
+      val client = liveClient()
+      val utility = client.getUtility()
+      val root = client.getRootCtx()
+      val inner = "INNER-SECRET-$round"
+      utility.cleanAdd(root, inner)
+      utility.cleanAdd(root, "OUTER-$inner-TAIL")
+      val text = "a $inner b OUTER-$inner-TAIL c"
+      val masked = "a [redacted] b [redacted] c"
+      assertEquals(masked, utility.clean(root, text))
+
+      val registering = CountDownLatch(width / 2)
+      val wrong = ConcurrentLinkedQueue<Any?>()
+      val thrown = atOnce { n ->
+        if (n < width / 2) {
+          registerSecrets(utility, root, round, n, registering)
+        } else {
+          while (0L < registering.count) {
+            val cleaned = utility.clean(root, text)
+            if (masked != cleaned) {
+              wrong.add(cleaned)
+            }
+          }
+        }
+      }
+
+      assertTrue(thrown.isEmpty(), "round $round threw: $thrown")
+      assertTrue(wrong.isEmpty(), "round $round cleaned to: $wrong")
+      assertEverySecretMasked(utility, root, round)
+    }
+  }
+
+  // Requests on one client while secrets register on it: each request copies
+  // the client's options, the registry among them.
+  @Test
+  fun concurrentRequestsSurviveRegistration() {
+    repeat(rounds / 4) { round ->
+      val client = liveClient()
+      val utility = client.getUtility()
+      val root = client.getRootCtx()
+      val registering = CountDownLatch(width / 2)
+      val failed = ConcurrentLinkedQueue<Any?>()
+      val thrown = atOnce { n ->
+        if (n < width / 2) {
+          registerSecrets(utility, root, round, n, registering)
+        } else {
+          while (0L < registering.count) {
+            val res = client.direct(linkedMapOf<String, Any?>("path" to "p$n"))
+            if (true != res["ok"]) {
+              failed.add(res)
+              break
+            }
+          }
+        }
+      }
+
+      assertTrue(thrown.isEmpty(), "round $round threw: $thrown")
+      assertTrue(failed.isEmpty(), "round $round, a request failed: $failed")
+      assertEverySecretMasked(utility, root, round)
+    }
+  }
+}

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

@@ -68,7 +68,7 @@ private fun stripAction(reqdata: Any?): Any? = omitKeys(reqdata, listOf("\$actio
 
 // A header, cookie or query argument travels where prepareHeaders or
 // prepareQuery sends it, so the body is built from the request data without
-// it, unless the entity declares it as a field too.
+// it, unless the point marks it as a field the body keeps.
 private fun routedArgNames(ctx: Context): List<String> =
   (callArgs(ctx, "header") + callArgs(ctx, "cookie") + callArgs(ctx, "query")).map { it.name }
     .filter { !fieldArg(ctx, it) }

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

@@ -48,7 +48,7 @@ end
 
 -- A header, cookie or query argument travels where prepare_headers_util or
 -- prepare_query_util sends it, so the body is built from the request data
--- without it, unless the entity declares it as a field too.
+-- without it, unless the point marks it as a field the body keeps.
 local function routed_arg_names(ctx)
   local names = {}
   for _, kind in ipairs({ "header", "cookie", "query" }) do

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

@@ -1,11 +1,12 @@
 # Makefile for the ProjectName OCaml SDK (generated by @voxgig/sdkgen).
 #
 # The SDK is dependency-free: it compiles with the stock bytecode compiler
-# (ocamlc) — no opam packages, no dune. Four test executables are built:
-#   run_sdk_test        — the SDK pipeline + feature suite (Testutil harness)
-#   run_omni_smoke      — the vendored omni runner's own failure paths
-#   run_struct_corpus   — the shared voxgig/struct JSON corpus
-#   run_primary_corpus  — the shared primary-utility JSON corpus
+# (ocamlc) — no opam packages, no dune. The test executables:
+#   run_sdk_test         — the SDK pipeline + feature suite (Testutil harness)
+#   run_omni_smoke       — the vendored omni runner's own failure paths
+#   run_struct_corpus    — the shared voxgig/struct JSON corpus
+#   run_primary_corpus   — the shared primary-utility JSON corpus
+#   run_concurrency_test — requests on several threads at once on one client
 #
 # The two corpus suites run on the VENDORED @voxgig/omni engine
 # (test/vendor/omni/omni.ml), driven through its native API by the local
@@ -95,6 +96,11 @@ CLEAN_TESTS = $(sort $(wildcard test/clean_test.ml))
 # Wildcard so an absent file is simply skipped, never a missing-target error.
 DOC_TESTS = $(sort $(wildcard test/readme_examples_test.ml))
 
+# Requests on several threads at once on one client. Only this executable
+# links the threads library; the SDK itself never does.
+CONCURRENCY_SRC = $(RUNTIME) sdk_config.ml $(ENTITIES) sdk_client.ml sdk_error.ml \
+  test/testutil.ml test/concurrency_test.ml
+
 # Fixed test order: harness deps first, generated/behaviour tests, the gated
 # feature suites, summary last.
 SDK_TEST = $(RUNTIME) sdk_config.ml $(ENTITIES) sdk_client.ml sdk_error.ml \
@@ -117,9 +123,9 @@ PRIMARY_SRC = $(RUNTIME) sdk_config.ml $(ENTITIES) sdk_client.ml sdk_error.ml \
 SMOKE_SRC = utility/vregex.ml utility/voxgig_struct.ml \
   $(OMNI) test/omni_smoke_test.ml
 
-.PHONY: test test-sdk test-omni test-corpus test-primary build lint clean
+.PHONY: test test-sdk test-omni test-corpus test-primary test-concurrency build lint clean
 
-test: test-sdk test-omni test-corpus test-primary
+test: test-sdk test-omni test-corpus test-primary test-concurrency
 
 test-sdk: run_sdk_test
 	./run_sdk_test
@@ -133,6 +139,9 @@ test-corpus: run_struct_corpus
 test-primary: run_primary_corpus
 	./run_primary_corpus $(CORPUS)
 
+test-concurrency: run_concurrency_test
+	./run_concurrency_test
+
 # Every executable that links the RUNTIME links the gated feature tier with
 # it: library archives FIRST (an archive must precede the modules that use
 # it), stub objects and link flags LAST.
@@ -148,6 +157,10 @@ run_struct_corpus: $(CORPUS_SRC)
 run_primary_corpus: $(PRIMARY_SRC) $(FEATURE_OBJ)
 	$(OCAMLC) $(INC) $(FEATURE_LIB) $(PRIMARY_SRC) $(FEATURE_OBJ) $(FEATURE_LINK) -o run_primary_corpus
 
+run_concurrency_test: $(CONCURRENCY_SRC) $(FEATURE_OBJ)
+	$(OCAMLC) $(INC) -I +unix -I +threads unix.cma threads.cma $(filter-out unix.cma,$(FEATURE_LIB)) \
+	  $(CONCURRENCY_SRC) $(FEATURE_OBJ) $(FEATURE_LINK) -o run_concurrency_test
+
 # Type-check the SDK library (a clean compile means it is sound).
 build: lint
 lint:
@@ -159,4 +172,4 @@ clean:
 	  test/vendor/omni/*.cmi test/vendor/omni/*.cmo \
 	  feature/*.cmi feature/*.cmo feature/*/*/*.cmi feature/*/*/*.cmo \
 	  feature/*/*/*.o test/feature/*/*.cmi test/feature/*/*.cmo \
-	  run_sdk_test run_omni_smoke run_struct_corpus run_primary_corpus a.out
+	  run_sdk_test run_omni_smoke run_struct_corpus run_primary_corpus run_concurrency_test a.out

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

@@ -159,10 +159,19 @@ let default_ctxspec () : ctxspec =
     cs_reqdata = None; cs_match = None; cs_reqmatch = None; cs_point = None;
     cs_spec = None; cs_result = None; cs_response = None }
 
+(* Every request racing to build this Operation gets the one stored first. *)
+let rec store_op (opmap : operation OpMap.t Atomic.t) (key : string) (op : operation) : operation =
+  let seen = Atomic.get opmap in
+  match OpMap.find_opt key seen with
+  | Some stored -> stored
+  | None ->
+    if Atomic.compare_and_set opmap seen (OpMap.add key op seen) then op
+    else store_op opmap key op
+
 let resolve_op (ctx : ctx) (opname : string) : operation =
   let entname = match ctx.c_entity with Some e -> e.e_name | None -> "_" in
   let cache_key = entname ^ ":" ^ opname in
-  match Hashtbl.find_opt ctx.c_opmap cache_key with
+  match OpMap.find_opt cache_key (Atomic.get ctx.c_opmap) with
   | Some op -> op
   | None ->
     if opname = "" then new_operation (empty_map ())
@@ -177,8 +186,7 @@ let resolve_op (ctx : ctx) (opname : string) : operation =
       let op = new_operation
           (jo [("entity", Str entname); ("name", Str opname);
                ("input", Str inpt); ("points", points)]) in
-      Hashtbl.replace ctx.c_opmap cache_key op;
-      op
+      store_op ctx.c_opmap cache_key op
     end
 
 let make_context_impl (cs : ctxspec) (basectx : ctx option) : ctx =
@@ -226,7 +234,7 @@ let make_context_impl (cs : ctxspec) (basectx : ctx option) : ctx =
     | _ -> (match basectx with Some b -> b.c_shared | None -> Noval) in
   let opmap =
     match cs.cs_opmap with Some h -> h
-    | None -> (match basectx with Some b -> b.c_opmap | None -> Hashtbl.create 16) in
+    | None -> (match basectx with Some b -> b.c_opmap | None -> Atomic.make OpMap.empty) in
   let mapof = function Some d -> (match to_map d with Map _ as m -> m | _ -> empty_map ()) | None -> empty_map () in
   let data = mapof cs.cs_data and reqdata = mapof cs.cs_reqdata
   and mtch = mapof cs.cs_match and reqmatch = mapof cs.cs_reqmatch in
@@ -321,18 +329,25 @@ let clean_forms (value : string) : string list =
    if String.length j >= 2 then add (String.sub j 1 (String.length j - 2)));
   !out
 
+(* A registration reads the registry list and writes a new one, so requests
+ * on other domains registering at once take turns, or one would be dropped.
+ * Cleaning reads the list whole and needs no turn. *)
+let clean_registering = Atomic.make false
+
 let clean_add_util (ctx : ctx) (value : string) : unit =
   let cfg = clean_config ctx in
   let minlen = match getp cfg "min" with Num n -> int_of_float n | _ -> 4 in
   match getp cfg "values" with
   | List r when String.length value >= minlen ->
-    let have = str_values (List r) in
-    let add = List.filter (fun f -> String.length f >= minlen && not (List.mem f have))
-        (clean_forms value) in
-    (* Longest first, so a value is never masked by a substring of itself. *)
-    if add <> [] then
-      r := List.map (fun s -> Str s)
-          (List.stable_sort (fun a b -> compare (String.length b) (String.length a)) (have @ add))
+    while not (Atomic.compare_and_set clean_registering false true) do () done;
+    Fun.protect ~finally:(fun () -> Atomic.set clean_registering false) (fun () ->
+        let have = str_values (List r) in
+        let add = List.filter (fun f -> String.length f >= minlen && not (List.mem f have))
+            (clean_forms value) in
+        (* Longest first, so a value is never masked by a substring of itself. *)
+        if add <> [] then
+          r := List.map (fun s -> Str s)
+              (List.stable_sort (fun a b -> compare (String.length b) (String.length a)) (have @ add)))
   | _ -> ()
 
 let mask_value (cfg : value) (value : string) : string =
@@ -1011,7 +1026,7 @@ let field_arg (ctx : ctx) (name : string) : bool =
 
 (* A header, cookie or query argument travels where prepare_headers_util or
    prepare_query_util sends it, so the body is built from the request data
-   without it, unless the entity declares it as a field too. *)
+   without it, unless the point marks it as a field the body keeps. *)
 let routed_arg_names (ctx : ctx) : string list =
   List.filter (fun name -> not (field_arg ctx name))
     (List.map (fun (name, _, _) -> name)

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

@@ -17,6 +17,8 @@
 
 open Voxgig_struct
 
+module OpMap = Map.Make (String)
+
 (* Branded SDK error. Raised as `Sdk_error_exc` on the throwing path; carried
  * as `sdk_error option` on the (value, err) pipeline return tuples. *)
 type sdk_error = {
@@ -238,7 +240,7 @@ and ctxspec = {
   mutable cs_options : value option;
   mutable cs_entity : entity_obj option;
   mutable cs_shared : value option;
-  mutable cs_opmap : (string, operation) Hashtbl.t option;
+  mutable cs_opmap : operation OpMap.t Atomic.t option;
   mutable cs_data : value option;
   mutable cs_reqdata : value option;
   mutable cs_match : value option;
@@ -261,7 +263,9 @@ and ctx = {
   mutable c_config : value;
   mutable c_entopts : value;
   mutable c_options : value;
-  mutable c_opmap : (string, operation) Hashtbl.t;
+  (* Shared by every context of one client, so by requests on other domains:
+   * a map replaced whole, never changed in place. *)
+  mutable c_opmap : operation OpMap.t Atomic.t;
   mutable c_response : response option;
   mutable c_result : result option;
   mutable c_spec : spec option;

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

@@ -0,0 +1,148 @@
+(* Requests in flight at once on one client. Each resolves its operation
+ * through the cache the client's root context shares with every request, and
+ * registers and cleans secrets through the one registry the client holds.
+ *
+ * Threads take turns on one domain and switch when the runtime's tick lands,
+ * so each test runs long enough to be switched inside a resolution or a
+ * registration. *)
+
+open Voxgig_struct
+open Sdk_types
+open Testutil
+
+let rounds = 3
+let width = 8
+let ops = 4000
+let seeded = 600
+let added = 100
+let masked = "a [redacted] b [redacted] c"
+
+(* Runs body on width threads released together, and returns what they raised. *)
+let at_once (body : int -> unit) : string list =
+  let lock = Mutex.create () in
+  let ready = Condition.create () in
+  let waiting = ref 0 in
+  let raised = ref [] in
+  let run n =
+    Mutex.lock lock;
+    incr waiting;
+    if !waiting = width then Condition.broadcast ready
+    else while !waiting < width do Condition.wait ready lock done;
+    Mutex.unlock lock;
+    try body n
+    with e ->
+      Mutex.lock lock;
+      raised := fail_msg e :: !raised;
+      Mutex.unlock lock
+  in
+  List.iter Thread.join (List.init width (Thread.create run));
+  !raised
+
+let root_of (cl : sdk_client) : ctx =
+  match cl.cl_rootctx with Some c -> c | None -> failwith "no root context"
+
+let resolve (cl : sdk_client) (k : int) : operation =
+  let ctx = cl.cl_utility.u_make_context
+      { (Sdk_runtime.default_ctxspec ()) with cs_opname = Some ("op" ^ string_of_int k) }
+      cl.cl_rootctx in
+  ctx.c_op
+
+let () = test "concurrent resolutions share one cached operation" (fun () ->
+    for round = 1 to rounds do
+      let cl = Sdk_client.test () in
+      let got = Array.init width (fun _ -> Array.make ops None) in
+      let raised = at_once (fun n ->
+          for k = 0 to ops - 1 do got.(n).(k) <- Some (resolve cl k) done) in
+      check (Printf.sprintf "round %d raised: %s" round (String.concat "; " raised)) (raised = []);
+      for k = 0 to ops - 1 do
+        let cached = resolve cl k in
+        for n = 0 to width - 1 do
+          check (Printf.sprintf "round %d: op%d resolved to more than one Operation" round k)
+            (match got.(n).(k) with Some op -> op == cached | None -> false)
+        done
+      done
+    done)
+
+let clean_str (cl : sdk_client) (text : string) : string =
+  match cl.cl_utility.u_clean (root_of cl) (Str text) with Str s -> s | v -> stringify v
+
+(* A live client whose transport answers at once. *)
+let live_client () : sdk_client =
+  let fetch = Func (fun _ _ _ _ ->
+      Sdk_helpers.jo [
+        ("status", Num 200.); ("statusText", Str "OK"); ("headers", Sdk_helpers.jo []);
+        ("json", Sdk_helpers.json_thunk (Sdk_helpers.jo [("ok", Bool true)]))]) in
+  Sdk_client.make (Sdk_helpers.jo [
+      ("base", Str "http://concurrency.test/api");
+      ("allow", Sdk_helpers.jo [("op", Str "direct")]);
+      ("system", Sdk_helpers.jo [("fetch", fetch)])])
+
+(* Registers thread n's secrets, then counts the thread out of registering. *)
+let register_secrets (cl : sdk_client) (round : int) (n : int) (registering : int Atomic.t) : unit =
+  Fun.protect ~finally:(fun () -> Atomic.decr registering) (fun () ->
+      for k = 1 to added do
+        cl.cl_utility.u_clean_add (root_of cl) (Printf.sprintf "ADDED-SECRET-%d-%d-%d" round n k)
+      done)
+
+let every_secret_masked (cl : sdk_client) (round : int) : unit =
+  for n = 0 to width / 2 - 1 do
+    for k = 1 to added do
+      let secret = Printf.sprintf "ADDED-SECRET-%d-%d-%d" round n k in
+      check_str (Printf.sprintf "round %d: %s was registered but not masked" round secret)
+        (clean_str cl secret) "[redacted]"
+    done
+  done
+
+(* Secrets registered on some threads while others clean: every clean masks
+ * what was registered before it, the longer secret whole, and no
+ * registration is lost. *)
+let () = test "concurrent registration keeps every secret masked" (fun () ->
+    for round = 1 to rounds do
+      let cl = Sdk_client.test () in
+      let add v = cl.cl_utility.u_clean_add (root_of cl) v in
+      for k = 1 to seeded do add (Printf.sprintf "SEEDED-SECRET-%d-%d" round k) done;
+      let inner = Printf.sprintf "INNER-SECRET-%d" round in
+      add inner;
+      add ("OUTER-" ^ inner ^ "-TAIL");
+      let text = "a " ^ inner ^ " b OUTER-" ^ inner ^ "-TAIL c" in
+      check_str (Printf.sprintf "round %d" round) (clean_str cl text) masked;
+      let registering = Atomic.make (width / 2) in
+      let raised = at_once (fun n ->
+          if n < width / 2 then register_secrets cl round n registering
+          else
+            while 0 < Atomic.get registering do
+              let got = clean_str cl text in
+              if got <> masked then failwith ("cleaned to: " ^ got);
+              Thread.yield ()
+            done) in
+      check (Printf.sprintf "round %d raised: %s" round (String.concat "; " raised)) (raised = []);
+      every_secret_masked cl round
+    done)
+
+(* Requests on one client while secrets register on it: each request copies
+ * the client's options, the registry among them. *)
+let () = test "concurrent requests survive registration" (fun () ->
+    for round = 1 to rounds do
+      let cl = live_client () in
+      for k = 1 to seeded do
+        cl.cl_utility.u_clean_add (root_of cl) (Printf.sprintf "SEEDED-SECRET-%d-%d" round k)
+      done;
+      let registering = Atomic.make (width / 2) in
+      let raised = at_once (fun n ->
+          if n < width / 2 then register_secrets cl round n registering
+          else
+            while 0 < Atomic.get registering do
+              let res = Sdk_client.direct cl
+                  (Sdk_helpers.jo [("path", Str (Printf.sprintf "p%d" n))]) in
+              if Sdk_helpers.getp res "ok" <> Bool true then
+                failwith ("a request failed: " ^ stringify res);
+              Thread.yield ()
+            done) in
+      check (Printf.sprintf "round %d raised: %s" round (String.concat "; " raised)) (raised = []);
+      every_secret_masked cl round
+    done)
+
+let () =
+  List.iter (fun m -> print_endline ("FAIL " ^ m)) (List.rev !failures);
+  Printf.printf "concurrency_test: %d passed, %d failed\n" !npass !nfail;
+  if !nfail > 0 then exit 1

package/project/.sdk/tm/perl/utility/transform_request.pm

@@ -44,7 +44,7 @@ my $field_arg = sub {
 
 # A header, cookie or query argument travels where prepare_headers or
 # prepare_query sends it, so the body is built from the request data without
-# it, unless the entity declares it as a field too.
+# it, unless the point marks it as a field the body keeps.
 my $routed_arg_names = sub {
   my ($ctx) = @_;
   return grep { !$field_arg->($ctx, $_) } map { $_->[0] } ProjectNameUtilities::call_args($ctx, 'header'),

package/project/.sdk/tm/php/feature/TestFeature.php

@@ -392,7 +392,7 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
 
     /**
      * Build a structured `$AND` query from the request match/data dict,
-     * matching the TS test feature's buildArgs. Mirrors ts/src/feature/test/TestFeature.ts:158-204.
+     * matching the TS test feature's buildArgs in ts/src/feature/test/TestFeature.ts.
      *
      * For each key in $args that is 'id' OR a required-param key on the
      * current operation point, emit a `$OR` clause matching the key (and
@@ -409,12 +409,12 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
         }
 
         $opname = is_object($op) ? ($op->name ?? null) : (\Voxgig\Struct\Struct::getprop($op, 'name'));
-        $entityName = null;
-        if (isset($ctx->entity)) {
-            $entityName = is_object($ctx->entity)
-                ? ($ctx->entity->name ?? null)
-                : (is_array($ctx->entity) ? ($ctx->entity['name'] ?? null) : null);
-        }
+
+        // An entity keeps its name private, behind get_name(); a context
+        // with no entity has the name its operation was resolved for.
+        $entityName = (is_object($ctx->entity) && method_exists($ctx->entity, 'get_name'))
+            ? $ctx->entity->get_name()
+            : (is_object($op) ? ($op->entity ?? null) : \Voxgig\Struct\Struct::getprop($op, 'entity'));
 
         // Resolve required-param names from the op's last point. Defensive:
         // any missing piece falls back to "no required params".
@@ -427,8 +427,8 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
             // `{id}` marks a record route, and failing that the shallower
             // path wins.
             $points = \Voxgig\Struct\Struct::getpath(
-                ['entity', $entityName, 'op', $opname, 'points'],
-                $ctx->config
+                $ctx->config,
+                ['entity', $entityName, 'op', $opname, 'points']
             );
             $point = \Voxgig\Struct\Struct::getelem($points, 0);
             if (is_array($points)) {

package/project/.sdk/tm/php/utility/TransformRequest.php

@@ -37,7 +37,7 @@ class ProjectNameTransformRequest
 
     // A header, cookie or query argument travels where PrepareHeaders or
     // PrepareQuery sends it, so the body is built from the request data
-    // without it, unless the entity declares it as a field too.
+    // without it, unless the point marks it as a field the body keeps.
     private static function routed_arg_names(ProjectNameContext $ctx): array
     {
         $args = array_merge(ProjectNameParam::callArgs($ctx, 'header'),

package/project/.sdk/tm/py/pkg/core/context.py

@@ -202,8 +202,8 @@ class ProjectNameContext:
             "points": points,
         })
 
-        self.opmap[cache_key] = op
-        return op
+        # Every request racing to build this Operation gets the one stored first.
+        return self.opmap.setdefault(cache_key, op)
 
     def make_error(self, code, msg):
         return ProjectNameError(code, msg, self)

package/project/.sdk/tm/py/pkg/utility/clean.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 import base64
 import json
+import threading
 from urllib.parse import quote
 
 from projectname_sdk.schema import OPTSPEC
@@ -113,20 +114,23 @@ def _forms(value):
     return out
 
 
+# Requests on other threads clean while one registers, so a registration
+# publishes a new list and never changes a published one.
+_REGISTERING = threading.Lock()
+
+
 # Register a secret value. Idempotent; shorter than `min` is not a secret
 # the SDK can mask without blanking ordinary text.
 def clean_add_util(ctx, value):
     cfg = _clean_config(ctx)
     if not isinstance(value, str) or len(value) < cfg["min"]:
         return
-    values = cfg["values"]
-    changed = False
-    for form in _forms(value):
-        if len(form) >= cfg["min"] and form not in values:
-            values.append(form)
-            changed = True
-    if changed:
-        values.sort(key=len, reverse=True)
+    with _REGISTERING:
+        values = cfg["values"]
+        added = [form for form in _forms(value)
+                 if len(form) >= cfg["min"] and form not in values]
+        if added:
+            cfg["values"] = sorted(values + added, key=len, reverse=True)
 
 
 # Every scalar under a sensitive name, at any depth and of any shape: a

package/project/.sdk/tm/py/pkg/utility/transform_request.py

@@ -14,7 +14,7 @@ def _strip_action(reqdata):
 
 # A header, cookie or query argument travels where prepare_headers_util or
 # prepare_query_util sends it, so the body is built from the request data
-# without it, unless the entity declares it as a field too.
+# without it, unless the point marks it as a field the body keeps.
 def _routed_arg_names(ctx):
     return [name for name, _orig, _val in
             call_args(ctx, "header") + call_args(ctx, "cookie") + call_args(ctx, "query")