@voxgig/sdkgen 0.45.0 → 1.0.1

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

@@ -5,25 +5,47 @@ declare(strict_types=1);
 
 class ProjectNameFetcher
 {
+    // Default User-Agent — many CDNs (notably Cloudflare) reject requests
+    // with PHP's default UA (which file_get_contents doesn't even set),
+    // returning 403 before the request reaches the origin. Set a Mozilla-
+    // shaped UA so the SDK behaves like every other HTTP client by default.
+    // Users can override by passing a User-Agent header in fetchdef.
+    public const DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)';
+
     public static function defaultHttpFetch(string $fullurl, array $fetchdef): array
     {
-        $method_str = $fetchdef['method'] ?? 'GET';
+        $method_str = strtoupper($fetchdef['method'] ?? 'GET');
         $body_str = $fetchdef['body'] ?? null;
         $headers = $fetchdef['headers'] ?? [];
 
-        $opts = [
-            'http' => [
-                'method' => strtoupper($method_str),
-                'ignore_errors' => true,
-            ],
-        ];
-
         $header_lines = [];
+        $has_ua = false;
         foreach ($headers as $k => $v) {
             if (is_string($v)) {
+                if (strcasecmp($k, 'user-agent') === 0) {
+                    $has_ua = true;
+                }
                 $header_lines[] = "{$k}: {$v}";
             }
         }
+        if (!$has_ua) {
+            $header_lines[] = 'User-Agent: ' . self::DEFAULT_USER_AGENT;
+        }
+
+        // Prefer cURL when available — its header capture is reliable across
+        // PHP versions, while file_get_contents + custom stream wrappers
+        // don't propagate $http_response_header for user-defined wrappers
+        // in PHP 8.3+.
+        if (function_exists('curl_init')) {
+            return self::curlFetch($fullurl, $method_str, $body_str, $header_lines);
+        }
+
+        $opts = [
+            'http' => [
+                'method' => $method_str,
+                'ignore_errors' => true,
+            ],
+        ];
 
         if (is_string($body_str)) {
             $opts['http']['content'] = $body_str;
@@ -78,6 +100,101 @@ class ProjectNameFetcher
         ];
     }
 
+    private static function curlFetch(string $fullurl, string $method, $body_str, array $header_lines): array
+    {
+        // GET-only guard for live tests — set by pub-live-test. We respect
+        // it here at the SDK level since cURL bypasses PHP stream wrappers
+        // (so the wrapper-based guard wouldn't see this call).
+        if (getenv('VOXGIG_GETONLY_GUARD') === 'TRUE' && $method !== 'GET') {
+            fwrite(STDERR, "[GET-ONLY GUARD] blocked {$method} {$fullurl}\n");
+            return [
+                [
+                    'status' => 0,
+                    'statusText' => 'Blocked',
+                    'headers' => [],
+                    'json' => function () { return null; },
+                    'body' => '',
+                ],
+                "GET-only guard blocked {$method} {$fullurl}",
+            ];
+        }
+
+        $ch = curl_init($fullurl);
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_HEADER, false);
+        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);
+        curl_setopt($ch, CURLOPT_TIMEOUT, 30);
+        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
+        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
+        if (!empty($header_lines)) {
+            curl_setopt($ch, CURLOPT_HTTPHEADER, $header_lines);
+        }
+        if (is_string($body_str)) {
+            curl_setopt($ch, CURLOPT_POSTFIELDS, $body_str);
+        }
+
+        $resp_headers = [];
+        curl_setopt($ch, CURLOPT_HEADERFUNCTION,
+            function ($_ch, $hdr) use (&$resp_headers) {
+                $trimmed = trim($hdr);
+                if ($trimmed !== '') {
+                    $resp_headers[] = $trimmed;
+                }
+                return strlen($hdr);
+            });
+
+        $response_body = curl_exec($ch);
+        if ($response_body === false) {
+            $err = curl_error($ch) ?: 'curl_exec failed';
+            curl_close($ch);
+            return [
+                [
+                    'status' => 0,
+                    'statusText' => 'Error',
+                    'headers' => [],
+                    'json' => function () { return null; },
+                    'body' => '',
+                ],
+                $err,
+            ];
+        }
+        curl_close($ch);
+
+        $status = 0;
+        $status_text = '';
+        $resp_kv = [];
+        foreach ($resp_headers as $h) {
+            if (preg_match('/^HTTP\/\S+\s+(\d+)\s*(.*)$/i', $h, $m)) {
+                $status = (int)$m[1];
+                $status_text = trim($m[2]);
+            } else {
+                $parts = explode(':', $h, 2);
+                if (count($parts) === 2) {
+                    $resp_kv[strtolower(trim($parts[0]))] = trim($parts[1]);
+                }
+            }
+        }
+
+        $json_body = null;
+        if ($response_body !== '' && $response_body !== false) {
+            $decoded = json_decode($response_body, true);
+            if (json_last_error() === JSON_ERROR_NONE) {
+                $json_body = $decoded;
+            }
+        }
+
+        return [
+            [
+                'status' => $status,
+                'statusText' => $status_text,
+                'headers' => $resp_kv,
+                'json' => function () use ($json_body) { return $json_body; },
+                'body' => (string)$response_body,
+            ],
+            null,
+        ];
+    }
+
     public static function call(ProjectNameContext $ctx, string $fullurl, array $fetchdef): array
     {
         if ($ctx->client->mode !== 'live') {
@@ -93,7 +210,13 @@ class ProjectNameFetcher
 
         $sys_fetch = \Voxgig\Struct\Struct::getpath($options, 'system.fetch');
 
-        if ($sys_fetch === null) {
+        // Treat null OR an empty stdClass/array as "no fetcher provided" and
+        // fall through to the default HTTP fetcher. The options builder
+        // sometimes materializes `system.fetch` as an empty stdClass even
+        // when the user didn't set one — that's a placeholder, not a value.
+        $is_empty_obj = ($sys_fetch instanceof \stdClass) && empty(get_object_vars($sys_fetch));
+        $is_empty_arr = is_array($sys_fetch) && empty($sys_fetch);
+        if ($sys_fetch === null || $is_empty_obj || $is_empty_arr) {
             return self::defaultHttpFetch($fullurl, $fetchdef);
         }
         if (is_callable($sys_fetch)) {

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

@@ -35,6 +35,22 @@ class ProjectNameMakeUrl
             }
         }
 
+        // Append query string from spec.query.
+        $qsep = '?';
+        $query_items = \Voxgig\Struct\Struct::items($spec->query ?? null);
+        if ($query_items) {
+            foreach ($query_items as $item) {
+                $key = $item[0];
+                $val = $item[1];
+                if ($val !== null && is_string($key)) {
+                    $val_str = is_string($val) ? $val : (string)$val;
+                    $url .= $qsep . \Voxgig\Struct\Struct::escurl($key) . '=' . \Voxgig\Struct\Struct::escurl($val_str);
+                    $qsep = '&';
+                    $resmatch[$key] = $val;
+                }
+            }
+        }
+
         $result->resmatch = $resmatch;
         return [$url, null];
     }

package/project/.sdk/tm/py/feature/test_feature.py

@@ -52,8 +52,21 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
             if not isinstance(entmap, dict):
                 entmap = {}
 
+            # For single-entity ops (load, remove) with an empty explicit
+            # match, fall back to the id the entity client already knows from a
+            # prior create/load (in fctx.match / fctx.data). Mirrors the TS
+            # mock where param() resolves the id from that accumulated state.
+            def _resolve_match(explicit):
+                if isinstance(explicit, dict) and len(explicit) > 0:
+                    return explicit
+                for src in (getattr(fctx, "match", None), getattr(fctx, "data", None)):
+                    v = vs.getprop(src, "id") if src is not None else None
+                    if v is not None and v != "__UNDEFINED__":
+                        return {"id": v}
+                return {}
+
             if op.name == "load":
-                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                args = test_self.build_args(fctx, op, _resolve_match(fctx.reqmatch))
                 found = vs.select(entmap, args)
                 ent = vs.getelem(found, 0)
                 if ent is None:
@@ -74,9 +87,28 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                 return respond(200, out)
 
             elif op.name == "update":
-                args = test_self.build_args(fctx, op, fctx.reqdata)
+                # Match the existing entity by id only (or its alias). reqdata
+                # also contains the new field values, which would otherwise
+                # cause select to filter out the entity we want to update.
+                # Falls back to first entity when no match found, mirroring
+                # the TS mock.
+                update_match = {}
+                if isinstance(fctx.reqdata, dict):
+                    if "id" in fctx.reqdata:
+                        update_match["id"] = fctx.reqdata["id"]
+                    alias_map = getattr(op, "alias_map", None)
+                    if alias_map is not None:
+                        alias_id = vs.getprop(alias_map, "id")
+                        if alias_id is not None and alias_id in fctx.reqdata:
+                            update_match[alias_id] = fctx.reqdata[alias_id]
+                args = test_self.build_args(fctx, op, update_match)
                 found = vs.select(entmap, args)
                 ent = vs.getelem(found, 0)
+                if ent is None and isinstance(entmap, dict):
+                    for e in entmap.values():
+                        if isinstance(e, dict):
+                            ent = e
+                            break
                 if ent is None:
                     return respond(404, None, {"statusText": "Not found"})
                 if isinstance(ent, dict):
@@ -89,7 +121,7 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
                 return respond(200, out)
 
             elif op.name == "remove":
-                args = test_self.build_args(fctx, op, fctx.reqmatch)
+                args = test_self.build_args(fctx, op, _resolve_match(fctx.reqmatch))
                 found = vs.select(entmap, args)
                 ent = vs.getelem(found, 0)
                 if ent is None:

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

@@ -62,6 +62,54 @@ class ProjectNameTestRunner:
 
         return m
 
+    _test_control = None
+
+    @staticmethod
+    def load_test_control():
+        """Load sdk-test-control.json from this test dir; cache after first read.
+        Returns a dict with the empty-skip default if the file is missing or invalid
+        so tests never crash on a bad config.
+        """
+        if ProjectNameTestRunner._test_control is not None:
+            return ProjectNameTestRunner._test_control
+        ctrl_path = os.path.join(os.path.dirname(__file__), "sdk-test-control.json")
+        try:
+            with open(ctrl_path, "r") as f:
+                ProjectNameTestRunner._test_control = json.load(f)
+        except (FileNotFoundError, IOError, ValueError):
+            ProjectNameTestRunner._test_control = {
+                "version": 1,
+                "test": {"skip": {
+                    "live": {"direct": [], "entityOp": []},
+                    "unit": {"direct": [], "entityOp": []},
+                }},
+            }
+        return ProjectNameTestRunner._test_control
+
+    @staticmethod
+    def is_control_skipped(kind, name, mode):
+        """Check sdk-test-control.json for a skip entry. Returns (skip, reason)."""
+        ctrl = ProjectNameTestRunner.load_test_control()
+        skip = ctrl.get("test", {}).get("skip", {}).get(mode, {}) or {}
+        items = skip.get(kind, []) or []
+        for item in items:
+            if kind == "direct" and item.get("test") == name:
+                return True, item.get("reason")
+            if kind == "entityOp":
+                key = (item.get("entity") or "") + "." + (item.get("op") or "")
+                if key == name:
+                    return True, item.get("reason")
+        return False, None
+
+    @staticmethod
+    def live_delay_ms():
+        """Per-test live pacing delay (ms); default 500."""
+        ctrl = ProjectNameTestRunner.load_test_control()
+        v = ctrl.get("test", {}).get("live", {}).get("delayMs")
+        if isinstance(v, int) and v >= 0:
+            return v
+        return 500
+
     @staticmethod
     def entity_list_to_data(lst):
         out = []
@@ -88,3 +136,15 @@ def env_override(m):
 
 def entity_list_to_data(lst):
     return ProjectNameTestRunner.entity_list_to_data(lst)
+
+
+def is_control_skipped(kind, name, mode):
+    return ProjectNameTestRunner.is_control_skipped(kind, name, mode)
+
+
+def load_test_control():
+    return ProjectNameTestRunner.load_test_control()
+
+
+def live_delay_ms():
+    return ProjectNameTestRunner.live_delay_ms()

package/project/.sdk/tm/py/test/sdk-test-control.json

@@ -0,0 +1,19 @@
+{
+  "version": 1,
+  "_doc": "Per-SDK test control. Lists tests/operations to skip in unit and live modes; tunes per-test pacing. Edit by hand. Loaded by py test runner.",
+  "test": {
+    "skip": {
+      "live": {
+        "direct": [],
+        "entityOp": []
+      },
+      "unit": {
+        "direct": [],
+        "entityOp": []
+      }
+    },
+    "live": {
+      "delayMs": 500
+    }
+  }
+}

package/project/.sdk/tm/py/utility/fetcher.py

@@ -5,6 +5,14 @@ import json
 from utility.voxgig_struct import voxgig_struct as vs
 
 
+# Default User-Agent — many CDNs (notably Cloudflare) reject requests with
+# Python's default urllib UA ("Python-urllib/3.x"), returning 403 before
+# the request even reaches the origin. Set a Mozilla-shaped UA so the SDK
+# behaves like every other HTTP client by default. Users can still override
+# by passing a User-Agent header in fetchdef.
+_DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)"
+
+
 def _default_http_fetch(fullurl, fetchdef):
     import urllib.request
     import urllib.error
@@ -19,8 +27,13 @@ def _default_http_fetch(fullurl, fetchdef):
     data = body_str.encode("utf-8") if body_str is not None else None
 
     req = urllib.request.Request(fullurl, data=data, method=method)
+    has_ua = False
     for k, v in headers.items():
+        if k.lower() == "user-agent":
+            has_ua = True
         req.add_header(k, v)
+    if not has_ua:
+        req.add_header("User-Agent", _DEFAULT_USER_AGENT)
 
     try:
         resp = urllib.request.urlopen(req)

package/project/.sdk/tm/py/utility/make_url.py

@@ -29,6 +29,19 @@ def make_url_util(ctx):
                 url = url.replace("{" + key + "}", encoded)
                 resmatch[key] = val
 
+    # Append query string from spec.query.
+    qsep = "?"
+    query_items = vs.items(getattr(spec, "query", None))
+    if query_items is not None:
+        for item in query_items:
+            key = item[0]
+            val = item[1]
+            if val is not None and isinstance(key, str):
+                val_str = val if isinstance(val, str) else str(val)
+                url += qsep + vs.escurl(key) + "=" + vs.escurl(val_str)
+                qsep = "&"
+                resmatch[key] = val
+
     result.resmatch = resmatch
 
     return url, None

package/project/.sdk/tm/rb/feature/test_feature.rb

@@ -48,8 +48,22 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
       entmap = VoxgigStruct.getprop(entity, op.entity)
       entmap = {} unless entmap.is_a?(Hash)
 
+      # For single-entity ops (load, remove) with an empty explicit match, fall
+      # back to the id the entity client already knows from a prior create/load
+      # (in fctx.match / fctx.data). Mirrors the TS mock where param() resolves
+      # the id from that accumulated state.
+      resolve_match = lambda do |explicit|
+        return explicit if explicit.is_a?(Hash) && !explicit.empty?
+        [fctx.match, fctx.data].each do |src|
+          next if src.nil?
+          v = VoxgigStruct.getprop(src, "id")
+          return { "id" => v } if !v.nil? && v != "__UNDEFINED__"
+        end
+        {}
+      end
+
       if op.name == "load"
-        args = test_self.build_args(fctx, op, fctx.reqmatch)
+        args = test_self.build_args(fctx, op, resolve_match.call(fctx.reqmatch))
         found = VoxgigStruct.select(entmap, args)
         ent = VoxgigStruct.getelem(found, 0)
         return respond.call(404, nil, { "statusText" => "Not found" }) unless ent
@@ -68,9 +82,28 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         respond.call(200, out, nil)
 
       elsif op.name == "update"
-        args = test_self.build_args(fctx, op, fctx.reqdata)
+        # Match the existing entity by id only (or its alias). reqdata also
+        # contains the new field values, which would otherwise cause select
+        # to filter out the entity we want to update. Falls back to first
+        # entity when no id present and no match found, mirroring the TS
+        # mock's empirical behavior where param(undef) collapses to "no
+        # constraint" and select returns all.
+        update_match = {}
+        if fctx.reqdata.is_a?(Hash)
+          update_match["id"] = fctx.reqdata["id"] if fctx.reqdata.key?("id")
+          if op.alias_map
+            alias_id = VoxgigStruct.getprop(op.alias_map, "id")
+            if alias_id && fctx.reqdata.key?(alias_id)
+              update_match[alias_id] = fctx.reqdata[alias_id]
+            end
+          end
+        end
+        args = test_self.build_args(fctx, op, update_match)
         found = VoxgigStruct.select(entmap, args)
         ent = VoxgigStruct.getelem(found, 0)
+        if ent.nil? && entmap.is_a?(Hash) && !entmap.empty?
+          ent = entmap.values.find { |e| e.is_a?(Hash) }
+        end
         return respond.call(404, nil, { "statusText" => "Not found" }) unless ent
         if ent.is_a?(Hash) && fctx.reqdata
           fctx.reqdata.each { |k, v| ent[k] = v }
@@ -80,7 +113,7 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         respond.call(200, out, nil)
 
       elsif op.name == "remove"
-        args = test_self.build_args(fctx, op, fctx.reqmatch)
+        args = test_self.build_args(fctx, op, resolve_match.call(fctx.reqmatch))
         found = VoxgigStruct.select(entmap, args)
         ent = VoxgigStruct.getelem(found, 0)
         return respond.call(404, nil, { "statusText" => "Not found" }) unless ent

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

@@ -62,6 +62,52 @@ module ProjectNameTestRunner
     end
     out
   end
+
+  @test_control = nil
+
+  # Load sdk-test-control.json from this test dir; cache. Returns the
+  # empty-skip default if the file is missing or invalid.
+  def self.load_test_control
+    return @test_control unless @test_control.nil?
+    ctrl_path = File.join(File.dirname(__FILE__), 'sdk-test-control.json')
+    @test_control = begin
+      JSON.parse(File.read(ctrl_path))
+    rescue StandardError
+      {
+        'version' => 1,
+        'test' => { 'skip' => {
+          'live' => { 'direct' => [], 'entityOp' => [] },
+          'unit' => { 'direct' => [], 'entityOp' => [] },
+        }},
+      }
+    end
+    @test_control
+  end
+
+  # Check sdk-test-control.json for a skip entry. Returns [skip, reason].
+  def self.is_control_skipped(kind, name, mode)
+    ctrl = load_test_control
+    skip = (ctrl.dig('test', 'skip', mode) || {})
+    items = skip[kind] || []
+    items.each do |item|
+      if kind == 'direct' && item['test'] == name
+        return [true, item['reason']]
+      end
+      if kind == 'entityOp'
+        key = "#{item['entity']}.#{item['op']}"
+        return [true, item['reason']] if key == name
+      end
+    end
+    [false, nil]
+  end
+
+  # Per-test live pacing delay (ms); default 500.
+  def self.live_delay_ms
+    ctrl = load_test_control
+    v = ctrl.dig('test', 'live', 'delayMs')
+    return v if v.is_a?(Integer) && v >= 0
+    500
+  end
 end
 
 # Module-level aliases for test convenience.

package/project/.sdk/tm/rb/test/sdk-test-control.json

@@ -0,0 +1,19 @@
+{
+  "version": 1,
+  "_doc": "Per-SDK test control. Lists tests/operations to skip in unit and live modes; tunes per-test pacing. Edit by hand. Loaded by rb test runner.",
+  "test": {
+    "skip": {
+      "live": {
+        "direct": [],
+        "entityOp": []
+      },
+      "unit": {
+        "direct": [],
+        "entityOp": []
+      }
+    },
+    "live": {
+      "delayMs": 500
+    }
+  }
+}

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

@@ -10,39 +10,60 @@ module ProjectNameUtilities
     body_str = fetchdef["body"]
     headers = fetchdef["headers"] || {}
 
-    uri = URI.parse(fullurl)
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = (uri.scheme == "https")
+    begin
+      uri = URI.parse(fullurl)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
 
-    klass = case method_str.upcase
-            when "POST" then Net::HTTP::Post
-            when "PUT" then Net::HTTP::Put
-            when "DELETE" then Net::HTTP::Delete
-            when "PATCH" then Net::HTTP::Patch
-            else Net::HTTP::Get
-            end
+      klass = case method_str.upcase
+              when "POST" then Net::HTTP::Post
+              when "PUT" then Net::HTTP::Put
+              when "DELETE" then Net::HTTP::Delete
+              when "PATCH" then Net::HTTP::Patch
+              else Net::HTTP::Get
+              end
 
-    request = klass.new(uri)
-    headers.each { |k, v| request[k] = v.to_s if v.is_a?(String) }
-    request.body = body_str if body_str.is_a?(String)
+      request = klass.new(uri)
+      has_ua = false
+      headers.each do |k, v|
+        next unless v.is_a?(String)
+        has_ua = true if k.to_s.downcase == 'user-agent'
+        request[k] = v.to_s
+      end
+      # Default User-Agent — Net::HTTP sets "Ruby" which some CDNs block.
+      # Use a Mozilla-shaped UA unless the caller already set one.
+      request['User-Agent'] = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)' unless has_ua
+      request.body = body_str if body_str.is_a?(String)
 
-    resp = http.request(request)
-    resp_headers = {}
-    resp.each_header { |k, v| resp_headers[k.downcase] = v }
+      resp = http.request(request)
+      resp_headers = {}
+      resp.each_header { |k, v| resp_headers[k.downcase] = v }
 
-    json_body = nil
-    begin
-      json_body = JSON.parse(resp.body) if resp.body && !resp.body.empty?
-    rescue JSON::ParserError
-    end
+      json_body = nil
+      begin
+        json_body = JSON.parse(resp.body) if resp.body && !resp.body.empty?
+      rescue JSON::ParserError
+      end
 
-    return {
-      "status" => resp.code.to_i,
-      "statusText" => resp.message,
-      "headers" => resp_headers,
-      "json" => -> { json_body },
-      "body" => resp.body,
-    }, nil
+      return {
+        "status" => resp.code.to_i,
+        "statusText" => resp.message,
+        "headers" => resp_headers,
+        "json" => -> { json_body },
+        "body" => resp.body,
+      }, nil
+    rescue StandardError => e
+      # Network-level failures (DNS, TCP, TLS, timeouts) — return a synthesized
+      # response with status 0 so callers can branch on result.ok like any
+      # other failed request, instead of seeing an unhandled exception.
+      return {
+        "status" => 0,
+        "statusText" => "#{e.class}: #{e.message}",
+        "headers" => {},
+        "json" => -> { nil },
+        "body" => nil,
+      }, nil
+    end
   }
 
   Fetcher = ->(ctx, fullurl, fetchdef) {

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

@@ -26,6 +26,22 @@ module ProjectNameUtilities
       end
     end
 
+    # Append query string from spec.query.
+    qsep = "?"
+    query_items = VoxgigStruct.items(spec.respond_to?(:query) ? spec.query : nil)
+    if query_items
+      query_items.each do |item|
+        key = item[0]
+        val = item[1]
+        if val && key.is_a?(String)
+          val_str = val.is_a?(String) ? val : val.to_s
+          url += qsep + VoxgigStruct.escurl(key) + "=" + VoxgigStruct.escurl(val_str)
+          qsep = "&"
+          resmatch[key] = val
+        end
+      end
+    end
+
     result.resmatch = resmatch
     return url, nil
   }

package/project/.sdk/tm/ts/test/sdk-test-control.json

@@ -0,0 +1,19 @@
+{
+  "version": 1,
+  "_doc": "Per-SDK test control. Lists tests/operations to skip in unit and live modes; tunes per-test pacing. Edit by hand. Loaded by ts/test/utility.ts.",
+  "test": {
+    "skip": {
+      "live": {
+        "direct": [],
+        "entityOp": []
+      },
+      "unit": {
+        "direct": [],
+        "entityOp": []
+      }
+    },
+    "live": {
+      "delayMs": 500
+    }
+  }
+}