@voxgig/sdkgen 4.34.1 → 4.34.2

package/project/.sdk/tm/py/test/test_concurrency.py

@@ -0,0 +1,177 @@
+# ProjectName SDK concurrency test
+#
+# 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 sys
+import threading
+
+from projectname_sdk import ProjectNameSDK
+
+
+ROUNDS = 50
+WIDTH = 8
+OPS = 32
+MASKED = "a [redacted] b [redacted] c"
+
+
+# Runs body on WIDTH threads released together, and returns what they raised.
+def _at_once(body):
+    start = threading.Barrier(WIDTH)
+    raised = []
+
+    def run(n):
+        try:
+            start.wait()
+            body(n)
+        except BaseException as err:
+            raised.append(err)
+
+    threads = [threading.Thread(target=run, args=(n,)) for n in range(WIDTH)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
+    return raised
+
+
+# A live client whose transport answers at once.
+def _live_client():
+    def fetch(url, fetchdef):
+        return {
+            "status": 200,
+            "statusText": "OK",
+            "headers": {},
+            "json": lambda: {"ok": True},
+        }, None
+
+    return ProjectNameSDK({
+        "base": "http://concurrency.test/api",
+        "allow": {"op": "direct"},
+        "system": {"fetch": fetch},
+    })
+
+
+def _added_secret(rnd, n, k):
+    return "ADDED-SECRET-%d-%d-%d" % (rnd, n, k)
+
+
+# Half the threads register their secrets; the rest run body(n) until those
+# are done or body returns False. Returns what the threads raised.
+def _while_registering(utility, root, rnd, body):
+    lock = threading.Lock()
+    registering = [WIDTH // 2]
+    registered = threading.Event()
+
+    def work(n):
+        if n < WIDTH // 2:
+            try:
+                for k in range(OPS):
+                    utility.clean_add(root, _added_secret(rnd, n, k))
+            finally:
+                with lock:
+                    registering[0] -= 1
+                    if 0 == registering[0]:
+                        registered.set()
+            return
+        while not registered.is_set():
+            if not body(n):
+                return
+
+    return _at_once(work)
+
+
+# The first secret registered in the round that a clean leaves raw.
+def _unmasked_secret(utility, root, rnd):
+    for n in range(WIDTH // 2):
+        for k in range(OPS):
+            added = _added_secret(rnd, n, k)
+            if "[redacted]" != utility.clean(root, added):
+                return added
+    return None
+
+
+class TestConcurrency:
+
+    # Threads switch as often as the interpreter allows, so a race a few
+    # bytecodes wide has room to show.
+    def setup_method(self):
+        self._interval = sys.getswitchinterval()
+        sys.setswitchinterval(1e-6)
+
+    def teardown_method(self):
+        sys.setswitchinterval(self._interval)
+
+    def test_concurrent_resolutions_share_one_cached_operation(self):
+        for rnd in range(ROUNDS):
+            client = ProjectNameSDK.test(None, None)
+            utility = client.get_utility()
+            root = client.get_root_ctx()
+            ops = [[None] * OPS for _ in range(WIDTH)]
+
+            def resolve(n):
+                for k in range(OPS):
+                    ops[n][k] = utility.make_context({"opname": "op%d" % k}, root).op
+
+            raised = _at_once(resolve)
+
+            assert [] == raised, "round %d raised: %r" % (rnd, raised)
+            for k in range(OPS):
+                cached = utility.make_context({"opname": "op%d" % k}, root).op
+                for n in range(WIDTH):
+                    assert ops[n][k] is cached, \
+                        "round %d: op%d resolved to more than one Operation" % (rnd, k)
+
+    # 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.
+    def test_concurrent_registration_keeps_every_secret_masked(self):
+        for rnd in range(ROUNDS // 4):
+            client = ProjectNameSDK.test(None, None)
+            utility = client.get_utility()
+            root = client.get_root_ctx()
+            inner = "INNER-SECRET-%d" % rnd
+            utility.clean_add(root, inner)
+            utility.clean_add(root, "OUTER-" + inner + "-TAIL")
+            text = "a " + inner + " b OUTER-" + inner + "-TAIL c"
+            assert MASKED == utility.clean(root, text)
+
+            wrong = []
+
+            def clean(n):
+                got = utility.clean(root, text)
+                if MASKED != got:
+                    wrong.append(got)
+                    return False
+                return True
+
+            raised = _while_registering(utility, root, rnd, clean)
+
+            assert [] == raised, "round %d raised: %r" % (rnd, raised)
+            assert [] == wrong, "round %d cleaned to: %r" % (rnd, wrong)
+            added = _unmasked_secret(utility, root, rnd)
+            assert added is None, "round %d: %s was registered but not masked" % (rnd, added)
+
+    # Requests on one client while secrets register on it: each request
+    # copies the client's options, the registry among them.
+    def test_concurrent_requests_survive_registration(self):
+        for rnd in range(ROUNDS // 4):
+            client = _live_client()
+            utility = client.get_utility()
+            root = client.get_root_ctx()
+            failed = []
+
+            def request(n):
+                res = client.direct({"path": "p%d" % n})
+                if True is not res.get("ok"):
+                    failed.append(res)
+                    return False
+                return True
+
+            raised = _while_registering(utility, root, rnd, request)
+
+            assert [] == raised, "round %d raised: %r" % (rnd, raised)
+            assert [] == failed, "round %d, a request failed: %r" % (rnd, failed)
+            added = _unmasked_secret(utility, root, rnd)
+            assert added is None, "round %d: %s was registered but not masked" % (rnd, added)

package/project/.sdk/tm/rb/core/context.rb

@@ -10,6 +10,10 @@ require_relative 'error'
 require_relative 'helpers'
 
 class ProjectNameContext
+  # Every context of a client shares its root's operation cache. CRuby's GVL
+  # makes each Hash operation atomic; a Ruby without one needs this lock.
+  OPMAP_LOCK = Mutex.new
+
   attr_accessor :id, :out, :client, :utility, :ctrl, :meta, :config,
                 :entopts, :options, :entity, :shared, :opmap,
                 :data, :reqdata, :match, :reqmatch, :point,
@@ -83,7 +87,8 @@ class ProjectNameContext
     # served to every subsequent entity's call.
     entname = @entity&.respond_to?(:get_name) ? @entity.get_name : "_"
     cache_key = "#{entname}:#{opname}"
-    return @opmap[cache_key] if @opmap[cache_key]
+    cached = OPMAP_LOCK.synchronize { @opmap[cache_key] }
+    return cached if cached
     return ProjectNameOperation.new({}) if opname.empty?
 
     opcfg = VoxgigStruct.getpath(@config, "entity.#{entname}.op.#{opname}")
@@ -102,8 +107,8 @@ class ProjectNameContext
       "input" => input,
       "points" => points,
     })
-    @opmap[cache_key] = op
-    op
+    # Racing requests get the Operation stored first.
+    OPMAP_LOCK.synchronize { @opmap[cache_key] ||= op }
   end
 
   def make_error(code, msg)

package/project/.sdk/tm/rb/test/concurrency_test.rb

@@ -0,0 +1,160 @@
+# ProjectName SDK concurrency test
+#
+# 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.
+#
+# The interpreter switches threads about every 100ms, so each test runs long
+# enough to be switched in the middle of a resolution or a registration.
+
+require "minitest/autorun"
+require_relative "../ProjectName_sdk"
+
+class ConcurrencyTest < Minitest::Test
+  ROUNDS = 3
+  WIDTH = 8
+  OPS = 6000
+  SEEDED = 1000
+  ADDED = 400
+  MASKED = "a [redacted] b [redacted] c"
+
+  # Runs the block on WIDTH threads, released once every one is waiting, and
+  # returns what they raised.
+  def at_once
+    lock = Mutex.new
+    waiting = 0
+    ready = Queue.new
+    gate = Queue.new
+    seen = Queue.new
+    raised = Queue.new
+    threads = (0...WIDTH).map do |n|
+      Thread.new do
+        lock.synchronize { waiting += 1 }
+        ready << n
+        gate.pop
+        seen << lock.synchronize { waiting }
+        yield n
+      rescue Exception => e
+        raised << e
+      end
+    end
+    WIDTH.times { ready.pop }
+    WIDTH.times { gate << true }
+    threads.each(&:join)
+    released = Array.new(seen.size) { seen.pop }
+    assert_equal [WIDTH] * WIDTH, released, "threads released before #{WIDTH} were waiting"
+    Array.new(raised.size) { raised.pop }
+  end
+
+  def test_concurrent_resolutions_share_one_cached_operation
+    ROUNDS.times do |round|
+      client = ProjectNameSDK.test(nil, nil)
+      utility = client.get_utility
+      root = client.get_root_ctx
+      ops = Array.new(WIDTH) { Array.new(OPS) }
+
+      raised = at_once do |n|
+        OPS.times { |k| ops[n][k] = utility.make_context.call({ "opname" => "op#{k}" }, root).op }
+      end
+
+      assert_empty raised, "round #{round} raised: #{raised.inspect}"
+      OPS.times do |k|
+        cached = utility.make_context.call({ "opname" => "op#{k}" }, root).op
+        WIDTH.times do |n|
+          assert_same cached, ops[n][k], "round #{round}: op#{k} resolved to more than one Operation"
+        end
+      end
+    end
+  end
+
+  # A live client whose transport answers at once.
+  def live_client
+    ProjectNameSDK.new({
+      "base" => "http://concurrency.test/api",
+      "allow" => { "op" => "direct" },
+      "system" => {
+        "fetch" => lambda { |_url, _fetchdef|
+          [{ "status" => 200, "statusText" => "OK", "headers" => {},
+             "json" => lambda { { "ok" => true } } }, nil]
+        },
+      },
+    })
+  end
+
+  # Half the threads register their secrets; the rest run body until those
+  # are done or it returns false. Returns what the threads raised.
+  def while_registering(utility, root, &body)
+    lock = Mutex.new
+    registering = WIDTH / 2
+    at_once do |n|
+      if n < WIDTH / 2
+        begin
+          ADDED.times { |k| utility.clean_add.call(root, "ADDED-SECRET-#{n}-#{k}") }
+        ensure
+          lock.synchronize { registering -= 1 }
+        end
+      else
+        while 0 < lock.synchronize { registering }
+          break unless body.call(n)
+          Thread.pass
+        end
+      end
+    end
+  end
+
+  def assert_every_secret_masked(utility, root)
+    (WIDTH / 2).times do |n|
+      ADDED.times do |k|
+        added = "ADDED-SECRET-#{n}-#{k}"
+        assert_equal "[redacted]", utility.clean.call(root, added), "#{added} was registered but not masked"
+      end
+    end
+  end
+
+  # 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.
+  def test_concurrent_registration_keeps_every_secret_masked
+    client = ProjectNameSDK.test(nil, nil)
+    utility = client.get_utility
+    root = client.get_root_ctx
+    SEEDED.times { |k| utility.clean_add.call(root, "SEEDED-SECRET-#{k}") }
+    utility.clean_add.call(root, "INNER-SECRET")
+    utility.clean_add.call(root, "OUTER-INNER-SECRET-TAIL")
+    text = "a INNER-SECRET b OUTER-INNER-SECRET-TAIL c"
+    assert_equal MASKED, utility.clean.call(root, text)
+
+    wrong = Queue.new
+    raised = while_registering(utility, root) do
+      got = utility.clean.call(root, text)
+      wrong << got if MASKED != got
+      MASKED == got
+    end
+
+    cleaned = Array.new(wrong.size) { wrong.pop }
+    assert_empty raised, "raised: #{raised.inspect}"
+    assert_empty cleaned, "cleaned to: #{cleaned.inspect}"
+    assert_every_secret_masked(utility, root)
+  end
+
+  # Requests on one client while secrets register on it: each request copies
+  # the client's options, the registry among them.
+  def test_concurrent_requests_survive_registration
+    client = live_client
+    utility = client.get_utility
+    root = client.get_root_ctx
+    SEEDED.times { |k| utility.clean_add.call(root, "SEEDED-SECRET-#{k}") }
+
+    failed = Queue.new
+    raised = while_registering(utility, root) do |n|
+      res = client.direct({ "path" => "p#{n}" })
+      failed << res unless true == res["ok"]
+      true == res["ok"]
+    end
+
+    requests = Array.new(failed.size) { failed.pop }
+    assert_empty raised, "raised: #{raised.inspect}"
+    assert_empty requests, "a request failed: #{requests.inspect}"
+    assert_every_secret_masked(utility, root)
+  end
+end

package/project/.sdk/tm/rb/utility/clean.rb

@@ -83,19 +83,20 @@ module ProjectNameUtilities
       out
     end
 
+    # Requests on other threads clean while one registers, so a registration
+    # publishes a new list and never changes a published one.
+    REGISTERING = Mutex.new
+
     # Register a secret value. Idempotent; shorter than `min` is not a secret
     # the SDK can mask without blanking ordinary text.
     def self.add(ctx, value)
       cfg = config(ctx)
       return unless value.is_a?(String) && value.length >= cfg["min"]
-      values = cfg["values"]
-      changed = false
-      forms(value).each do |form|
-        next if form.length < cfg["min"] || values.include?(form)
-        values << form
-        changed = true
+      REGISTERING.synchronize do
+        values = cfg["values"]
+        added = forms(value).reject { |form| form.length < cfg["min"] || values.include?(form) }
+        cfg["values"] = (values + added).sort_by { |v| -v.length } unless added.empty?
       end
-      values.sort_by! { |v| -v.length } if changed
       nil
     end
 

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

@@ -11,7 +11,7 @@ module ProjectNameUtilities
 
   # 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.
   def self.routed_arg_names(ctx)
     (call_args(ctx, "header") + call_args(ctx, "cookie") + call_args(ctx, "query")).map(&:first)
       .reject { |name| field_arg?(ctx, name) }

package/project/.sdk/tm/rust/utility/transform_request.rs

@@ -14,7 +14,7 @@ fn strip_action(reqdata: Value) -> Value {
 
 // 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.
 fn routed_arg_names(ctx: &Rc<Context>) -> Vec<String> {
     let mut names = Vec::new();
     for kind in ["header", "cookie", "query"] {

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

@@ -18,12 +18,14 @@ build:
 # and so runs in every scala SDK, model-activated or not. SdkCleanTestMain is
 # the canary sweep: no credential leaves the SDK in any form. SdkServerTestMain
 # checks how a templated base URL takes its server variables.
+# SdkConcurrencyTestMain races first requests on one client.
 test:
 	scala-cli run . --main-class OmniSmoke
 	scala-cli run . --main-class SdkTestMain
 	scala-cli run . --main-class SdkEntityTestMain
 	scala-cli run . --main-class SdkCleanTestMain
 	scala-cli run . --main-class SdkServerTestMain
+	scala-cli run . --main-class SdkConcurrencyTestMain
 	scala-cli run . --main-class SecretsTestMain
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json
 	scala-cli run . --main-class PrimaryCorpusMain -- ../.sdk/test/test.json

package/project/.sdk/tm/scala/core/Context.scala

@@ -1,7 +1,7 @@
 package SCALAPACKAGE.core
 
 import java.util.{ArrayList, LinkedHashMap, List => JList, Map => JMap}
-import java.util.concurrent.ThreadLocalRandom
+import java.util.concurrent.{ConcurrentHashMap, ThreadLocalRandom}
 import SCALAPACKAGE.utility.struct.Struct
 
 // Per-operation context threaded through the pipeline and feature hooks.
@@ -85,7 +85,7 @@ class Context(ctxmap: JMap[String, Object], basectx: Context) {
     // Opmap
     Helpers.getCtxProp(ctxmap, "opmap") match { case om: JMap[_, _] => opmap = om.asInstanceOf[JMap[String, Operation]]; case _ => }
     if (opmap == null && basectx != null) opmap = basectx.opmap
-    if (opmap == null) opmap = new LinkedHashMap[String, Operation]()
+    if (opmap == null) opmap = new ConcurrentHashMap[String, Operation]()
 
     // Data
     data = Helpers.toMapAny(Helpers.getCtxProp(ctxmap, "data"))
@@ -153,8 +153,10 @@ class Context(ctxmap: JMap[String, Object], basectx: Context) {
     opdef.put("points", points)
 
     val newop = new Operation(opdef)
-    opmap.put(cacheKey, newop)
-    newop
+    // Requests on other threads share this cache; every one of them gets
+    // the Operation stored first.
+    val stored = opmap.putIfAbsent(cacheKey, newop)
+    if (stored != null) stored else newop
   }
 
   def makeError(code: String, msg: String): SdkError = new SdkError(code, msg, this)

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

@@ -0,0 +1,186 @@
+// 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, CountDownLatch, CyclicBarrier}
+import java.util.function.{BiFunction, Supplier}
+import java.util.{Map => JMap}
+
+import SCALAPACKAGE.core.{Context, Operation, ProjectNameSDK, Utility}
+
+object SdkConcurrencyTestMain {
+
+  private val Rounds = 200
+  private val Width = 8
+  private val Ops = 32
+
+  private def om(kv: (String, Object)*): JMap[String, Object] = SdkTestSupport.om(kv*)
+
+  // A live client whose transport answers at once.
+  private def liveClient(): ProjectNameSDK = {
+    val json: Supplier[Object] = () => om("ok" -> SdkTestSupport.B(true))
+    val fetch: BiFunction[String, JMap[String, Object], Object] = (_, _) =>
+      om("status" -> SdkTestSupport.I(200), "statusText" -> "OK", "headers" -> om(), "json" -> json)
+    new ProjectNameSDK(om(
+      "base" -> "http://concurrency.test/api",
+      "allow" -> om("op" -> "direct"),
+      "system" -> om("fetch" -> fetch)))
+  }
+
+  // Runs body on Width threads released together, and returns what they threw.
+  private def atOnce(body: Int => Unit): List[Throwable] = {
+    val start = new CyclicBarrier(Width)
+    val thrown = new ConcurrentLinkedQueue[Throwable]()
+    val threads = (0 until Width).map { n =>
+      val runner: Runnable = () =>
+        try {
+          start.await()
+          body(n)
+        }
+        catch { case e: Throwable => thrown.add(e); () }
+      val thread = new Thread(runner)
+      thread.start()
+      thread
+    }
+    threads.foreach(_.join())
+    thrown.toArray(new Array[Throwable](0)).toList
+  }
+
+  private def addedSecret(round: Int, n: Int, k: Int): String =
+    "ADDED-SECRET-" + round + "-" + n + "-" + k
+
+  // Registers thread n's secrets, then counts the thread out of registering.
+  private def registerSecrets(utility: Utility, root: Context, round: Int, n: Int,
+      registering: CountDownLatch): Unit =
+    try {
+      for (k <- 0 until Ops) utility.cleanAdd(root, addedSecret(round, n, k))
+    }
+    finally registering.countDown()
+
+  // The first secret registered in the round that a clean leaves raw.
+  private def unmasked(utility: Utility, root: Context, round: Int): Option[String] =
+    (for (n <- 0 until Width / 2; k <- 0 until Ops) yield addedSecret(round, n, k))
+      .find(added => "[redacted]" != utility.clean(root, added))
+
+  // The first failure across the rounds, or null.
+  private def firstFailure(round: Int => String): String = {
+    var failure: String = null
+    var n = 0
+    while (failure == null && n < Rounds) {
+      failure = round(n)
+      n += 1
+    }
+    failure
+  }
+
+  def main(args: Array[String]): Unit = {
+    val rep = new SdkTestReport()
+
+    rep.scope("concurrency.requests") {
+      val failure = firstFailure { round =>
+        // A fresh client each round, so every request in it is a first request.
+        val client = liveClient()
+        val results = new Array[JMap[String, Object]](Width)
+        val thrown = atOnce(n => results(n) = client.direct(om("path" -> ("p" + n))))
+        val failed = (0 until Width).find(n =>
+          results(n) == null || java.lang.Boolean.TRUE != results(n).get("ok"))
+        if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+        else failed.map(n => "round " + round + ", request " + n + " failed: " + results(n)).orNull
+      }
+      rep.check("concurrency.requests", failure == null, failure)
+    }
+
+    rep.scope("concurrency.operations") {
+      val failure = firstFailure { round =>
+        val client = liveClient()
+        val utility = client.getUtility()
+        val root = client.getRootCtx()
+        val got = Array.ofDim[Operation](Width, Ops)
+        val thrown = atOnce { n =>
+          for (k <- 0 until Ops) {
+            got(n)(k) = utility.makeContext(om("opname" -> ("op" + k)), root).op
+          }
+        }
+        val split = (0 until Ops).find { k =>
+          val cached = utility.makeContext(om("opname" -> ("op" + k)), root).op
+          (0 until Width).exists(n => !(got(n)(k) eq cached))
+        }
+        if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+        else split.map(k => "round " + round + ": op" + k + " resolved to more than one Operation").orNull
+      }
+      rep.check("concurrency.operations", failure == null, failure)
+    }
+
+    // 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.
+    rep.scope("concurrency.registry") {
+      val masked = "a [redacted] b [redacted] c"
+      val failure = firstFailure { round =>
+        if (round >= Rounds / 4) null
+        else {
+          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 before = utility.clean(root, text)
+          val registering = new CountDownLatch(Width / 2)
+          val wrong = new ConcurrentLinkedQueue[Object]()
+          val thrown = atOnce { n =>
+            if (n < Width / 2) registerSecrets(utility, root, round, n, registering)
+            else {
+              while (0L < registering.getCount) {
+                val got = utility.clean(root, text)
+                if (masked != got) wrong.add(got)
+              }
+            }
+          }
+          if (masked != before) "round " + round + " cleaned to: " + before
+          else if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+          else if (!wrong.isEmpty) "round " + round + " cleaned to: " + wrong
+          else unmasked(utility, root, round)
+            .map(added => "round " + round + ": " + added + " was registered but not masked").orNull
+        }
+      }
+      rep.check("concurrency.registry", failure == null, failure)
+    }
+
+    // Requests on one client while secrets register on it: each request
+    // copies the client's options, the registry among them.
+    rep.scope("concurrency.registry.requests") {
+      val failure = firstFailure { round =>
+        if (round >= Rounds / 4) null
+        else {
+          val client = liveClient()
+          val utility = client.getUtility()
+          val root = client.getRootCtx()
+          val registering = new CountDownLatch(Width / 2)
+          val failed = new ConcurrentLinkedQueue[Object]()
+          val thrown = atOnce { n =>
+            if (n < Width / 2) registerSecrets(utility, root, round, n, registering)
+            else {
+              var going = true
+              while (going && 0L < registering.getCount) {
+                val res = client.direct(om("path" -> ("p" + n)))
+                if (java.lang.Boolean.TRUE != res.get("ok")) {
+                  failed.add(res)
+                  going = false
+                }
+              }
+            }
+          }
+          if (thrown.nonEmpty) "round " + round + " threw: " + thrown
+          else if (!failed.isEmpty) "round " + round + ", a request failed: " + failed
+          else unmasked(utility, root, round)
+            .map(added => "round " + round + ": " + added + " was registered but not masked").orNull
+        }
+      }
+      rep.check("concurrency.registry.requests", failure == null, failure)
+    }
+
+    rep.finish("CONCURRENCY")
+  }
+}

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

@@ -28,7 +28,7 @@ object TransformRequest {
 
   // 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 def routedArgNames(ctx: Context): Seq[String] =
     (Param.callArgs(ctx, "header") ++ Param.callArgs(ctx, "cookie") ++ Param.callArgs(ctx, "query")).map(_._1)
       .filterNot(name => fieldArg(ctx, name))

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Context.swift

@@ -150,6 +150,8 @@ public final class Context {
     opm.entries["input"] = .string(input)
     opm.entries["points"] = .list(points)
 
+    // Each context holds its own copy of the cache, so a request racing
+    // another builds its own Operation, a read-only descriptor.
     let op = Operation(opm)
     opmap[cacheKey] = op
     return op