@voxgig/sdkgen 4.34.1 → 4.34.2

package/project/.sdk/src/cmp/ts/fragment/EntityLoadOp.fragment.ts

@@ -110,7 +110,7 @@ class EntityOperation {
       }
       else {
         // Off-happy-path (throw disabled): typed as any so the method's
-        // Promise<EntityName> return stays clean under strict null checks.
+        // Promise<EntyClass> return stays clean under strict null checks.
         return undefined as any
       }
     }

package/project/.sdk/src/cmp/ts/fragment/EntityPatchOp.fragment.ts

@@ -111,7 +111,7 @@ class EntityOperation {
       }
       else {
         // Off-happy-path (throw disabled): typed as any so the method's
-        // Promise<EntityName> return stays clean under strict null checks.
+        // Promise<EntyClass> return stays clean under strict null checks.
         return undefined as any
       }
     }

package/project/.sdk/src/cmp/ts/fragment/EntityUpdateOp.fragment.ts

@@ -111,7 +111,7 @@ class EntityOperation {
       }
       else {
         // Off-happy-path (throw disabled): typed as any so the method's
-        // Promise<EntityName> return stays clean under strict null checks.
+        // Promise<EntyClass> return stays clean under strict null checks.
         return undefined as any
       }
     }

package/project/.sdk/src/cmp/ts/utility_ts.ts

@@ -7,6 +7,7 @@ import {
   canonScalarKey,
   each,
   opParams,
+  jsQuote,
 } from '@voxgig/sdkgen'
 
 import {
@@ -55,7 +56,7 @@ function exampleValue(entity: any, op: any, paramName: string, placeholder: stri
   if ('NULL' === key) {
     return 'null'
   }
-  return `'${placeholder}'`
+  return jsQuote(placeholder)
 }
 
 

package/project/.sdk/src/cmp/zig/ReadmeEntity_zig.ts

@@ -6,7 +6,7 @@ import {
   getModelPath,
 } from '@voxgig/apidef'
 
-import { zigVarName } from './utility_zig'
+import { zigVarName, zigListMatch } from './utility_zig'
 
 
 // Canonical type sentinel -> a zig type name for the field/param tables.
@@ -27,6 +27,7 @@ function zigType(type: any): string {
 // A type-correct zig expression constructing a voxgig struct Value.
 function zigLit(type: any, placeholder: string = 'example'): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'h.vnull()'
   if ('INTEGER' === k || 'NUMBER' === k) return 'h.vnum(1)'
   if ('BOOLEAN' === k) return 'h.vbool(true)'
   if ('ARRAY' === k) return 'h.olist()'
@@ -154,7 +155,7 @@ switch (client.${method}(h.vnull()).load(${loadArg}, h.vnull())) {
       Content(`#### Example: List
 
 \`\`\`zig
-switch (client.${method}(h.vnull()).list(h.vnull(), h.vnull())) {
+switch (client.${method}(h.vnull()).list(${zigListMatch(entity)}, h.vnull())) {
     .ok => |${eVar}s| {
         for (${eVar}s) |${eVar}| {
             std.debug.print("{s}\\n", .{h.stringify(${eVar}.asEntity().data(null))});

package/project/.sdk/src/cmp/zig/ReadmeHowto_zig.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content, isAuthActive, envName, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, Content, isAuthActive, envName, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape, requiredItems } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -13,6 +13,7 @@ import { zigVarName } from './utility_zig'
 // A type-correct zig expression constructing a voxgig struct Value.
 function zigLit(type: any): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'h.vnull()'
   if ('INTEGER' === k || 'NUMBER' === k) return 'h.vnum(1)'
   if ('BOOLEAN' === k) return 'h.vbool(true)'
   if ('ARRAY' === k) return 'h.olist()'
@@ -36,13 +37,16 @@ const ReadmeHowto = cmp(function ReadmeHowto(props: any) {
   let testArg = 'h.vnull()'
   if (exampleEntity && isMatchOp) {
     testArg = idF ? `h.jo(&.{.{ "${idF}", h.vstr("test01") }})` : 'h.vnull()'
+  } else if (exampleEntity && 'list' === primaryOp && 0 < requiredItems(exampleEntity, 'list').length) {
+    const chosen = requiredItems(exampleEntity, 'list')
+    testArg = `h.jo(&.{${chosen.map((it: any) => `.{ ${JSON.stringify(it.name)}, ${zigLit(it.type)} }`).join(', ')}})`
   } else if (exampleEntity && ('create' === primaryOp || 'update' === primaryOp || 'patch' === primaryOp)) {
     const items = opRequestShape(exampleEntity, primaryOp).items
       .filter((it: any) => it.name !== idF && it.name !== 'id')
     const required = items.filter((it: any) => !it.optional)
     const chosen = required.length ? required : items.slice(0, 3)
     testArg = 0 < chosen.length
-      ? `h.jo(&.{${chosen.map((it: any) => `.{ "${it.name}", ${zigLit(it.type)} }`).join(', ')}})`
+      ? `h.jo(&.{${chosen.map((it: any) => `.{ ${JSON.stringify(it.name)}, ${zigLit(it.type)} }`).join(', ')}})`
       : 'h.omap()'
   }
 

package/project/.sdk/src/cmp/zig/ReadmeQuick_zig.ts

@@ -7,7 +7,7 @@ import {
   nom,
 } from '@voxgig/apidef'
 
-import { zigVarName } from './utility_zig'
+import { zigVarName, zigListMatch } from './utility_zig'
 
 
 const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
@@ -36,6 +36,7 @@ const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
   // A type-correct zig expression constructing a voxgig struct Value.
   const zigLit = (type: any, placeholder: string = 'example'): string => {
     const k = canonScalarKey(type)
+    if ('NULL' === k) return 'h.vnull()'
     if ('INTEGER' === k || 'NUMBER' === k) return 'h.vnum(1)'
     if ('BOOLEAN' === k) return 'h.vbool(true)'
     if ('ARRAY' === k) return 'h.olist()'
@@ -70,7 +71,7 @@ const client = ${ctor};
 it. \`asEntity().data(null)\` reads an entity's record.
 
 \`\`\`zig
-switch (client.${method}(h.vnull()).list(h.vnull(), h.vnull())) {
+switch (client.${method}(h.vnull()).list(${zigListMatch(exampleEntity)}, h.vnull())) {
     .ok => |${eVar}s| {
         for (${eVar}s) |${eVar}| {
             std.debug.print("{s}\\n", .{h.stringify(${eVar}.asEntity().data(null))});
@@ -191,7 +192,7 @@ switch (client.${method}(h.vnull()).update(h.jo(&.{${updatePairs.join(', ')}}),
         const patchPairs = (idF ? [`.{ "${idF}", ${idValueFor('patch')} }`] : []).concat(examplePairs('patch'))
         Content(`// Patch — sends only the fields given
 switch (client.${method}(h.vnull()).patch(h.jo(&.{${patchPairs.join(', ')}}), h.vnull())) {
-    .ok => |patched| std.debug.print("{s}\\n", .{h.stringify(patched)}),
+    .ok => |patched| std.debug.print("{s}\\n", .{h.stringify(patched.asEntity().data(null))}),
     .err => |e| std.debug.print("patch failed: {s}\\n", .{e.msg}),
 }
 

package/project/.sdk/src/cmp/zig/ReadmeRef_zig.ts

@@ -7,7 +7,7 @@ import {
   getModelPath,
 } from '@voxgig/apidef'
 
-import { zigVarName } from './utility_zig'
+import { zigVarName, zigListMatch } from './utility_zig'
 
 
 // Canonical type sentinel -> a zig type name for the field/param tables.
@@ -26,6 +26,7 @@ function zigType(type: any): string {
 // A type-correct zig expression constructing a voxgig struct Value.
 function zigLit(type: any, placeholder: string = 'example'): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'h.vnull()'
   if ('INTEGER' === k || 'NUMBER' === k) return 'h.vnum(1)'
   if ('BOOLEAN' === k) return 'h.vbool(true)'
   if ('ARRAY' === k) return 'h.olist()'
@@ -61,8 +62,8 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
       desc: 'Update an existing entity. The data must include the entity id. `.ok` carries the updated entity.',
     },
     patch: {
-      sig: 'patch(reqdata: Value, ctrl: Value) OpResult',
-      desc: 'Change part of an existing entity: only the fields given are sent. The data must include the entity id. `.ok` carries the patched entity data.',
+      sig: 'patch(reqdata: Value, ctrl: Value) EntResult',
+      desc: 'Change part of an existing entity: only the fields given are sent. The data must include the entity id. `.ok` carries the patched entity.',
     },
     remove: {
       sig: 'remove(reqmatch: Value, ctrl: Value) EntResult',
@@ -290,7 +291,7 @@ switch (client.${method}(h.vnull()).${opname}(${arg}, h.vnull())) {
           }
           else if ('list' === opname) {
             Content(`\`\`\`zig
-switch (client.${method}(h.vnull()).list(h.vnull(), h.vnull())) {
+switch (client.${method}(h.vnull()).list(${zigListMatch(ent)}, h.vnull())) {
     .ok => |results| {
         for (results) |result| {
             std.debug.print("{s}\\n", .{h.stringify(result.asEntity().data(null))});

package/project/.sdk/src/cmp/zig/ReadmeTopQuick_zig.ts

@@ -7,7 +7,7 @@ import {
   nom,
 } from '@voxgig/apidef'
 
-import { zigVarName } from './utility_zig'
+import { zigVarName, zigListMatch } from './utility_zig'
 
 
 // A type-correct zig expression constructing a voxgig struct Value for a
@@ -15,6 +15,7 @@ import { zigVarName } from './utility_zig'
 // render a typed literal.
 function zigLit(type: any, placeholder: string = 'example'): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'h.vnull()'
   if ('INTEGER' === k || 'NUMBER' === k) return 'h.vnum(1)'
   if ('BOOLEAN' === k) return 'h.vbool(true)'
   if ('ARRAY' === k) return 'h.olist()'
@@ -55,7 +56,7 @@ const client = ${ctor};
 
     if (opnames.includes('list')) {
       Content(`// List all ${eName.toLowerCase()}s (one entity per record, .err on failure)
-switch (client.${method}(h.vnull()).list(h.vnull(), h.vnull())) {
+switch (client.${method}(h.vnull()).list(${zigListMatch(exampleEntity)}, h.vnull())) {
     .ok => |${eVar}s| {
         for (${eVar}s) |${eVar}| {
             std.debug.print("{s}\\n", .{h.stringify(${eVar}.asEntity().data(null))});

package/project/.sdk/src/cmp/zig/ReadmeTopTest_zig.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape, requiredItems } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -13,6 +13,7 @@ import { zigVarName } from './utility_zig'
 // A type-correct zig expression constructing a voxgig struct Value.
 function zigLit(type: any): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'h.vnull()'
   if ('INTEGER' === k || 'NUMBER' === k) return 'h.vnum(1)'
   if ('BOOLEAN' === k) return 'h.vbool(true)'
   if ('ARRAY' === k) return 'h.olist()'
@@ -43,16 +44,16 @@ const client = sdk.test_sdk(h.vnull(), h.vnull());
     const idF = entityIdField(exampleEntity)
     const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
     let arg = 'h.vnull()'
-    if (isMatchOp) {
+    if (isMatchOp || ('list' === primaryOp && 0 < requiredItems(exampleEntity, 'list').length)) {
       // Every REQUIRED match key (id first) — the same shape that generates
       // the op's request match.
-      const items = opRequestShape(exampleEntity, primaryOp).items
-        .filter((it: any) => !it.optional || it.name === idF)
+      const items = (isMatchOp ? opRequestShape(exampleEntity, primaryOp).items
+        .filter((it: any) => !it.optional || it.name === idF) : requiredItems(exampleEntity, 'list'))
         .sort((a: any, b: any) =>
           (a.name === idF ? 0 : 1) - (b.name === idF ? 0 : 1))
       arg = 0 < items.length
         ? `h.jo(&.{${items.map((it: any) =>
-          `.{ "${it.name}", ${it.name === idF ? 'h.vstr("test01")' : zigLit(it.type)} }`).join(', ')}})`
+          `.{ ${JSON.stringify(it.name)}, ${isMatchOp && it.name === idF ? 'h.vstr("test01")' : zigLit(it.type)} }`).join(', ')}})`
         : 'h.vnull()'
     } else if ('create' === primaryOp || 'update' === primaryOp || 'patch' === primaryOp) {
       const items = opRequestShape(exampleEntity, primaryOp).items
@@ -60,7 +61,7 @@ const client = sdk.test_sdk(h.vnull(), h.vnull());
       const required = items.filter((it: any) => !it.optional)
       const chosen = required.length ? required : items.slice(0, 3)
       arg = 0 < chosen.length
-        ? `h.jo(&.{${chosen.map((it: any) => `.{ "${it.name}", ${zigLit(it.type)} }`).join(', ')}})`
+        ? `h.jo(&.{${chosen.map((it: any) => `.{ ${JSON.stringify(it.name)}, ${zigLit(it.type)} }`).join(', ')}})`
         : 'h.omap()'
     }
     const eVar = zigVarName(exampleEntity.name)

package/project/.sdk/src/cmp/zig/utility_zig.ts

@@ -4,6 +4,8 @@ import {
   walk,
 } from '@voxgig/struct'
 
+import { canonScalarKey, requiredItems } from '@voxgig/sdkgen'
+
 
 // Zig keywords that are illegal as a plain identifier.
 const ZIG_RESERVED = new Set<string>([
@@ -138,8 +140,19 @@ function clean(o: any, dropDefaults?: boolean): any {
   return prune(o, true === dropDefaults)
 }
 
+// A list's required route and query parameters, as the match it is called with.
+function zigListMatch(entity: any): string {
+  const lit = (type: any): string =>
+    (({ NULL: 'h.vnull()', INTEGER: 'h.vnum(1)', NUMBER: 'h.vnum(1)', BOOLEAN: 'h.vbool(true)', ARRAY: 'h.olist()', OBJECT: 'h.omap()' }) as any)[canonScalarKey(type)] ?? 'h.vstr("example")'
+  const items = requiredItems(entity, 'list')
+  return 0 < items.length
+    ? `h.jo(&.{${items.map((it: any) => `.{ ${JSON.stringify(it.name)}, ${lit(it.type)} }`).join(', ')}})`
+    : 'h.vnull()'
+}
+
 
 export {
+  zigListMatch,
   clean,
   formatZigValue,
   zigModuleName,

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

@@ -27,7 +27,7 @@ static bool field_arg(Context* ctx, const char* name) {
 
 /* 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. */
 static voxgig_value* routed_args(Context* ctx) {
   voxgig_value* routed = voxgig_new_list();
   for (size_t k = 0; k < 3; k++) {

package/project/.sdk/tm/clojure/src/sdk/core.clj

@@ -395,8 +395,8 @@
             points (let [t (when (vs/ismap opcfg) (vs/getprop opcfg "points"))]
                      (if (vs/islist t) t (vs/jt)))
             op (make-operation (vs/jm "entity" entname "name" opname "input" input "points" points))]
-        (swap! opmap assoc cache-key op)
-        op))))
+        ;; Every request racing to build this Operation gets the one stored first.
+        (get (swap! opmap #(if (contains? % cache-key) % (assoc % cache-key op))) cache-key)))))
 
 ;; ---------------------------------------------------------------------------
 ;; Feature dispatch.
@@ -488,19 +488,21 @@
   (let [n (try (long (Math/floor (Double/parseDouble (str v)))) (catch Exception _ nil))]
     (if (and n (<= 0 n)) n dflt)))
 
-;; The derived clean block: a struct map so it lives in options.__derived__
-;; and its `values` list stays MUTABLE after make-options - features register
-;; what they resolve later.
+;; The derived clean block: a java.util.Map so it lives in options.__derived__
+;; and its `values` list can be replaced after make-options - features
+;; register what they resolve later. Concurrent, so a clean or a request
+;; copying the options reads it without the lock and sees the last put.
 (defn make-clean-config [cleanopts]
   (let [o (fn [k] (mget cleanopts k))
         keys (vs/jt)]
     (doseq [k (splitkeys (o "keys"))] (.add ^java.util.List keys k))
-    (vs/jm "active" (not= false (o "active"))
-           "keys" keys
-           "values" (vs/jt)
-           "mask" (let [m (o "mask")] (if (string? m) m "[redacted]"))
-           "hint" (count-opt (o "hint") 0)
-           "min" (max 1 (count-opt (o "min") 4)))))
+    (doto (java.util.concurrent.ConcurrentHashMap.)
+      (.put "active" (not= false (o "active")))
+      (.put "keys" keys)
+      (.put "values" (vs/jt))
+      (.put "mask" (let [m (o "mask")] (if (string? m) m "[redacted]")))
+      (.put "hint" (count-opt (o "hint") 0))
+      (.put "min" (max 1 (count-opt (o "min") 4))))))
 
 ;; A context without options (make-error accepts a bare one) still masks by
 ;; the schema defaults.
@@ -521,21 +523,25 @@
 
 (defn u-clean-add [ctx value]
   (let [cfg (clean-config ctx)
-        minlen (long (or (mget cfg "min") 4))
-        values (mget cfg "values")]
-    (when (and (string? value) (>= (count value) minlen) (instance? java.util.List values))
-      (let [changed (atom false)]
-        (doseq [form (clean-forms value)]
-          (when (and (>= (count form) minlen) (not (.contains ^java.util.List values form)))
-            (.add ^java.util.List values form)
-            (reset! changed true)))
-        ;; Longest first, so a value is never masked by a substring of itself.
-        (when @changed
-          (let [sorted (sort-by (fn [^String s] (- (count s))) (vec values))]
-            (.clear ^java.util.List values)
-            (doseq [s sorted] (.add ^java.util.List values s))))))
+        minlen (long (or (mget cfg "min") 4))]
+    (when (and (string? value) (>= (count value) minlen)
+               (instance? java.util.List (mget cfg "values")))
+      (let [forms (filterv #(>= (count %) minlen) (clean-forms value))]
+        ;; Every request copies the options, the registry among them, so a
+        ;; registration publishes a new vector and never changes a published one.
+        (locking cfg
+          (let [values (vec (mget cfg "values"))
+                added (remove #(.contains ^java.util.List values %) forms)]
+            ;; Longest first, so a value is never masked by a substring of itself.
+            (when (seq added)
+              (.put ^java.util.Map cfg "values"
+                    (vec (sort-by (fn [^String s] (- (count s))) (into values added)))))))))
     nil))
 
+(defn- registered [cfg]
+  (let [values (mget cfg "values")]
+    (if (instance? java.util.List values) values [])))
+
 (defn- mask-value [cfg ^String value]
   (let [hint (long (or (mget cfg "hint") 0))
         mask (str (mget cfg "mask"))]
@@ -547,7 +553,7 @@
   (reduce (fn [^String out ^String value]
             (if (.contains out value) (str/replace out value (mask-value cfg value)) out))
           text
-          (vec (or (mget cfg "values") []))))
+          (registered cfg)))
 
 (defn- sensitive-key? [cfg key]
   (if (or (nil? key) (number? key))
@@ -1003,7 +1009,7 @@
 
 ;; A header, cookie or query argument travels where u-prepare-headers or
 ;; u-prepare-query 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.
 (defn- routed-arg-names [ctx]
   (->> (concat (call-args ctx "header") (call-args ctx "cookie") (call-args ctx "query"))
        (map first)

package/project/.sdk/tm/clojure/test/sdk/test/concurrency.clj

@@ -0,0 +1,136 @@
+;; ProjectName SDK concurrency tests - 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.
+(ns sdk.test.concurrency
+  (:require [sdk.core :as core]
+            [sdk.client :as client]
+            [sdk.testutil :as t]
+            [voxgig.struct :as vs])
+  (:import [java.util.concurrent ConcurrentLinkedQueue CountDownLatch CyclicBarrier]))
+
+(def ^:private rounds 200)
+(def ^:private width 8)
+(def ^:private ops 32)
+(def ^:private masked "a [redacted] b [redacted] c")
+
+;; Runs body on width threads released together, and returns what they threw.
+(defn- at-once [body]
+  (let [start (CyclicBarrier. width)
+        thrown (ConcurrentLinkedQueue.)
+        threads (mapv (fn [n]
+                        (doto (Thread. ^Runnable (fn []
+                                                   (try
+                                                     (.await start)
+                                                     (body n)
+                                                     (catch Throwable e (.add thrown e)))))
+                          (.start)))
+                      (range width))]
+    (doseq [^Thread thread threads] (.join thread))
+    (vec thrown)))
+
+(defn- resolve-op [root k]
+  (core/oget (core/make-context (vs/jm "opname" (str "op" k)) root) :op))
+
+(defn- resolutions-share-one-cached-operation []
+  (dotimes [round rounds]
+    (let [sdk (client/test-sdk nil nil)
+          root @(:root-ctx sdk)
+          got (vec (repeatedly width #(object-array ops)))
+          thrown (at-once (fn [n] (dotimes [k ops] (aset ^objects (got n) k (resolve-op root k)))))]
+      (t/is-true (empty? thrown) (str "round " round " threw: " (pr-str thrown)))
+      (dotimes [k ops]
+        (let [cached (resolve-op root k)]
+          (dotimes [n width]
+            (t/is-true (identical? cached (aget ^objects (got n) k))
+                       (str "round " round ": op" k " resolved to more than one Operation"))))))))
+
+;; A live client whose transport answers at once.
+(defn- live-sdk []
+  (client/make-sdk
+   (vs/jm "base" "http://concurrency.test/api"
+          "allow" (vs/jm "op" "direct")
+          "system" (vs/jm "fetch" (fn [_url _fetchdef]
+                                    [(vs/jm "status" 200 "statusText" "OK" "headers" (vs/jm)
+                                            "json" (fn [] (vs/jm "ok" true)))
+                                     nil])))))
+
+(defn- added-secret [round n k] (str "ADDED-SECRET-" round "-" n "-" k))
+
+;; Registers thread n's secrets, then counts the thread out of registering.
+(defn- register-secrets [clean-add ^CountDownLatch registering round n]
+  (try
+    (dotimes [k ops] (clean-add (added-secret round n k)))
+    (finally (.countDown registering))))
+
+(defn- every-secret-masked [clean round]
+  (dotimes [n (quot width 2)]
+    (dotimes [k ops]
+      (let [added (added-secret round n k)]
+        (t/is-eq (clean added) "[redacted]"
+                 (str "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.
+(defn- registration-keeps-every-secret-masked []
+  (dotimes [round (quot rounds 4)]
+    (let [sdk (client/test-sdk nil nil)
+          root @(:root-ctx sdk)
+          clean (fn [v] ((core/uget root :clean) root v))
+          clean-add (fn [v] ((core/uget root :clean-add) root v))
+          inner (str "INNER-SECRET-" round)
+          text (str "a " inner " b OUTER-" inner "-TAIL c")
+          _ (clean-add inner)
+          _ (clean-add (str "OUTER-" inner "-TAIL"))
+          _ (t/is-eq (clean text) masked (str "round " round))
+          registering (CountDownLatch. (quot width 2))
+          wrong (ConcurrentLinkedQueue.)
+          thrown (at-once
+                  (fn [n]
+                    (if (< n (quot width 2))
+                      (register-secrets clean-add registering round n)
+                      (loop []
+                        (when (pos? (.getCount registering))
+                          (let [got (clean text)]
+                            (if (= masked got) (recur) (.add wrong got))))))))]
+      (t/is-true (empty? thrown) (str "round " round " threw: " (pr-str thrown)))
+      (t/is-true (.isEmpty wrong) (str "round " round " cleaned to: " (pr-str (vec wrong))))
+      (every-secret-masked clean round))))
+
+;; Requests on one client while secrets register on it: each request copies
+;; the client's options, the registry among them.
+(defn- requests-survive-registration []
+  (dotimes [round (quot rounds 4)]
+    (let [sdk (live-sdk)
+          root @(:root-ctx sdk)
+          clean (fn [v] ((core/uget root :clean) root v))
+          clean-add (fn [v] ((core/uget root :clean-add) root v))
+          registering (CountDownLatch. (quot width 2))
+          failed (ConcurrentLinkedQueue.)
+          thrown (at-once
+                  (fn [n]
+                    (if (< n (quot width 2))
+                      (register-secrets clean-add registering round n)
+                      (loop []
+                        (when (pos? (.getCount registering))
+                          (let [res (client/direct sdk (vs/jm "path" (str "p" n)))]
+                            (if (true? (vs/getprop res "ok")) (recur) (.add failed res))))))))]
+      (t/is-true (empty? thrown) (str "round " round " threw: " (pr-str thrown)))
+      (t/is-true (.isEmpty failed) (str "round " round ", a request failed: " (pr-str (vec failed))))
+      (every-secret-masked clean round))))
+
+(defn run [rec]
+  (let [ran (atom 0)
+        failed (atom 0)
+        counting (fn [name ok? msg]
+                   (swap! ran inc)
+                   (when-not ok? (swap! failed inc))
+                   (rec name ok? msg))]
+    (t/run-check counting "concurrency-resolutions-share-one-cached-operation"
+                 resolutions-share-one-cached-operation)
+    (t/run-check counting "concurrency-registration-keeps-every-secret-masked"
+                 registration-keeps-every-secret-masked)
+    (t/run-check counting "concurrency-requests-survive-registration"
+                 requests-survive-registration)
+    (println (str "concurrency: " @ran " check(s), " @failed " failed"))))

package/project/.sdk/tm/clojure/test/sdk/test_runner.clj

@@ -1,6 +1,6 @@
 ;; ProjectName SDK test runner (tools.deps main entry point).
 ;; Runs the vendored omni runner's smoke test, the API-agnostic suites
-;; (primary utility, pipeline, features, netsim), the generated API-specific
+;; (primary utility, pipeline, features, netsim, concurrency), the generated API-specific
 ;; suite, and the vendored struct corpus, then reports counts and exits
 ;; non-zero on any failure. `--sdk-only` skips the corpus steps (see -main).
 (ns sdk.test-runner
@@ -11,6 +11,7 @@
             [sdk.test.struct-corpus :as corpus]
             [sdk.test.omni-smoke :as omnismoke]
             [sdk.test.clean :as clean]
+            [sdk.test.concurrency :as concurrency]
             [sdk.gentest :as gentest]
             [clojure.java.io :as io]))
 
@@ -119,6 +120,7 @@
     (feature/run rec)
     (run-feature-suites rec)
     (netsim/run rec)
+    (concurrency/run rec)
     (gentest/run rec)
     ;; The canary sweep (generated: sdk/test/clean.clj) prints its own
     ;; `clean: swept N surface(s), M leak(s)` line, which sdkgen's lane reads.

package/project/.sdk/tm/cpp/core/types.hpp

@@ -12,11 +12,14 @@
 #define SDK_CORE_TYPES_HPP
 
 #include <algorithm>
+#include <atomic>
 #include <cctype>
 #include <functional>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <ostream>
+#include <shared_mutex>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -51,7 +54,11 @@ using FeaturePtr = std::shared_ptr<Feature>;
 using UtilityPtr = std::shared_ptr<Utility>;
 using CtxPtr = std::shared_ptr<Context>;
 
-using OpMap = std::map<std::string, OperationPtr>;
+// Shared by every context of one client, so by requests on several threads.
+struct OpMap {
+  std::mutex lock;
+  std::map<std::string, OperationPtr> ops;
+};
 using OpMapPtr = std::shared_ptr<OpMap>;
 
 // Generated (core/config.hpp) — the embedded API config + feature factory.
@@ -623,6 +630,24 @@ public:
 
 // ---- SdkClient --------------------------------------------------------
 
+// A registration replaces the secret registry (options.__derived__.clean
+// .values) while requests copy the options: it holds this lock exclusively,
+// and every read of that slot holds it shared.
+inline std::shared_mutex& cleanRegistryLock() {
+  // winpthreads sets up a static rwlock on its first lock, failing threads
+  // that race it with EINVAL; that first lock runs in this static's
+  // initialization, which every other caller waits for.
+  struct Warmed {
+    std::shared_mutex lock;
+    Warmed() {
+      lock.lock();
+      lock.unlock();
+    }
+  };
+  static Warmed warmed;
+  return warmed.lock;
+}
+
 class SdkClient {
 public:
   std::string mode = "live";
@@ -744,7 +769,7 @@ inline SdkErrorPtr Helpers::unsupportedOp(const std::string& opname,
 
 // ---- Context ----
 inline Context::Context(const CtxSpec& cs, const CtxPtr& basectx) {
-  static long long counter = 10000000;
+  static std::atomic<long long> counter{10000000};
   id = "C" + std::to_string(++counter);
 
   // Client
@@ -826,8 +851,11 @@ inline OperationPtr Context::resolveOp(const std::string& opname) {
   if (entity) entname = entity->getName();
   std::string cacheKey = entname + ":" + opname;
 
-  auto it = opmap->find(cacheKey);
-  if (it != opmap->end()) return it->second;
+  {
+    std::lock_guard<std::mutex> guard(opmap->lock);
+    auto it = opmap->ops.find(cacheKey);
+    if (it != opmap->ops.end()) return it->second;
+  }
 
   if (opname.empty()) {
     return std::make_shared<Operation>(vmap());
@@ -852,8 +880,9 @@ inline OperationPtr Context::resolveOp(const std::string& opname) {
   map_put(opdef, "points", points);
 
   auto op_ = std::make_shared<Operation>(opdef);
-  (*opmap)[cacheKey] = op_;
-  return op_;
+  // Every request racing to build this Operation gets the one stored first.
+  std::lock_guard<std::mutex> guard(opmap->lock);
+  return opmap->ops.emplace(cacheKey, op_).first->second;
 }
 
 inline SdkErrorPtr Context::makeError(const std::string& code, const std::string& msg) {
@@ -951,6 +980,7 @@ inline SdkClient::SdkClient(const Value& options_) {
 }
 
 inline Value SdkClient::optionsMap() {
+  std::shared_lock<std::shared_mutex> guard(cleanRegistryLock());
   Value out = Struct::clone(options);
   return out.is_map() ? out : vmap();
 }