@voxgig/sdkgen 4.33.0 → 4.34.1

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

@@ -10,6 +10,7 @@ my $__dir;
 BEGIN { $__dir = File::Basename::dirname(Cwd::abs_path(__FILE__)) }
 require(Cwd::abs_path("$__dir/../lib/Voxgig/Struct.pm"));
 require(Cwd::abs_path("$__dir/../core/helpers.pm"));
+require(Cwd::abs_path("$__dir/param.pm"));
 
 package ProjectNameUtilities;
 
@@ -27,13 +28,27 @@ my $omit = sub {
 
 my $strip_action = sub { $omit->($_[0], '$action') };
 
-# A header argument travels as a header, which prepare_headers sends, so the
-# body is built from the request data without it.
-my $header_arg_names = sub {
-  my ($point) = @_;
-  my $hl = $point ? ProjectNameHelpers::gpath($point, 'args.header') : undef;
-  return () unless Voxgig::Struct::islist($hl);
-  return grep { defined $_ && !ref $_ && '' ne $_ } map { ProjectNameHelpers::gp($_, 'name') } @$hl;
+my $field_arg = sub {
+  my ($ctx, $name) = @_;
+  for my $kind (qw(header cookie query)) {
+    my $defs = $ctx->{point} ? ProjectNameHelpers::gpath($ctx->{point}, "args.$kind") : undef;
+    next unless Voxgig::Struct::islist($defs);
+    for my $ad (@$defs) {
+      my $n = ProjectNameHelpers::gp($ad, 'name');
+      return 1 if defined $n && !ref $n && $n eq $name &&
+        ProjectNameHelpers::rb_truthy(ProjectNameHelpers::gp($ad, 'field'));
+    }
+  }
+  return 0;
+};
+
+# 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.
+my $routed_arg_names = sub {
+  my ($ctx) = @_;
+  return grep { !$field_arg->($ctx, $_) } map { $_->[0] } ProjectNameUtilities::call_args($ctx, 'header'),
+    ProjectNameUtilities::call_args($ctx, 'cookie'), ProjectNameUtilities::call_args($ctx, 'query');
 };
 
 $REGISTRY{transform_request} = sub {
@@ -41,7 +56,7 @@ $REGISTRY{transform_request} = sub {
   my $spec = $ctx->{spec};
   my $point = $ctx->{point};
   $spec->{step} = 'reqform' if $spec;
-  my $data = $omit->($ctx->{reqdata}, $header_arg_names->($point));
+  my $data = $omit->($ctx->{reqdata}, $routed_arg_names->($ctx));
   my $transform = ProjectNameHelpers::to_map(ProjectNameHelpers::gp($point, 'transform'));
   return $strip_action->($data) unless $transform;
   my $reqform = ProjectNameHelpers::gp($transform, 'req');

package/project/.sdk/tm/php/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -125,7 +125,7 @@ class ProjectNameContext implements \JsonSerializable
 
         $opcfg = \Voxgig\Struct\Struct::getpath($this->config, "entity.{$entname}.op.{$opname}");
 
-        $input = ($opname === 'update' || $opname === 'create') ? 'data' : 'match';
+        $input = ($opname === 'update' || $opname === 'create' || $opname === 'patch') ? 'data' : 'match';
 
         $points = [];
         if (is_array($opcfg)) {

package/project/.sdk/tm/php/core/Response.php

@@ -11,6 +11,8 @@ class ProjectNameResponse
     public mixed $json_func;
     public mixed $body;
     public mixed $err;
+    // Set by a transport that could not read a non-blank body as JSON.
+    public bool $unreadable;
 
     public function __construct(array $resmap = [])
     {
@@ -26,5 +28,6 @@ class ProjectNameResponse
         $this->body = ($b === '__UNDEFINED__') ? null : $b;
         $e = \Voxgig\Struct\Struct::getprop($resmap, 'err');
         $this->err = ($e === '__UNDEFINED__') ? null : $e;
+        $this->unreadable = true === \Voxgig\Struct\Struct::getprop($resmap, 'unreadable');
     }
 }

package/project/.sdk/tm/php/core/Spec.php

@@ -18,6 +18,9 @@ class ProjectNameSpec
     public mixed $body;
     public string $url;
     public string $path;
+    // The query parameters prepare_auth placed: the credential, which the
+    // request sends and the entity's match leaves out.
+    public array $authquery;
 
     public function __construct(array $specmap = [])
     {
@@ -34,5 +37,6 @@ class ProjectNameSpec
         $this->body = $specmap['body'] ?? null;
         $this->url = $specmap['url'] ?? '';
         $this->path = $specmap['path'] ?? '';
+        $this->authquery = $specmap['authquery'] ?? [];
     }
 }

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

@@ -134,12 +134,11 @@ class ProjectNameCostFeature extends ProjectNameBaseFeature
         // A rejecting transport still costs an attempt. Without this, a run of
         // connection-level failures under `retry` (which catches and tries
         // again) would be charged nothing at all, and an onBudget 'deny'
-        // ceiling could never stop it.
-        $threw = null;
+        // ceiling could never stop it. Its error is answered as the pair the
+        // fetcher contract names, so make_error reports it as it does any.
         try {
             [$res, $err] = $inner($ctx, $url, $fetchdef);
         } catch (\Throwable $ex) {
-            $threw = $ex;
             $res = null;
             $err = $ex;
         }
@@ -184,10 +183,6 @@ class ProjectNameCostFeature extends ProjectNameBaseFeature
             }
         }
 
-        if ($threw !== null) {
-            throw $threw;
-        }
-
         return [$res, $err];
     }
 

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

@@ -12,6 +12,32 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
     private ?array $options;
     private int $_netcalls;
 
+    // The record the mock keeps: the request data without `$body`, which only the
+    // wire carries.
+    private static function record(mixed $reqdata): array
+    {
+        if (!is_array($reqdata)) {
+            return [];
+        }
+        unset($reqdata['$body']);
+        return $reqdata;
+    }
+
+    // The key a list's response transform
+    // ["`$EACH`", "body", ["`$MERGE`" => "`.<key>`"]] reads each item's record under.
+    private static function itemEnvelopeKey(mixed $restf): ?string
+    {
+        if (!is_array($restf) || !array_is_list($restf) || 3 !== count($restf) ||
+            '`$EACH`' !== $restf[0] || 'body' !== $restf[1] || !is_array($restf[2])) {
+            return null;
+        }
+        $merge = $restf[2]['`$MERGE`'] ?? null;
+        if (!is_string($merge) || !preg_match('/^`\.([^.`$]+)`$/', $merge, $m)) {
+            return null;
+        }
+        return $m[1];
+    }
+
     public function __construct()
     {
         parent::__construct();
@@ -66,6 +92,10 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                     return $data;
                 }
                 $restf = $transform['res'] ?? null;
+                $key = self::itemEnvelopeKey($restf);
+                if ($key !== null && is_array($data) && array_is_list($data)) {
+                    return array_map(fn($item) => [$key => $item], $data);
+                }
                 if (!is_string($restf)) {
                     return $data;
                 }
@@ -210,7 +240,7 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                 $out = \Voxgig\Struct\Struct::clone($cleaned);
                 return $respond(200, $out);
 
-            } elseif ($op->name === 'update') {
+            } elseif ($op->name === 'update' || $op->name === 'patch') {
                 // Match the existing entity by id only (or its alias). reqdata
                 // also contains the new field values, which would otherwise
                 // cause find_first to filter out the entity we want to update.
@@ -237,7 +267,7 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                     return $respond(404, null, ['statusText' => 'Not found']);
                 }
                 if (is_array($fctx->reqdata)) {
-                    $ent = \Voxgig\Struct\Struct::merge([$ent, $fctx->reqdata]);
+                    $ent = \Voxgig\Struct\Struct::merge([$ent, self::record($fctx->reqdata)]);
                 }
                 $id = is_array($ent) ? ($ent['id'] ?? null) : null;
                 if ($id !== null) {
@@ -267,7 +297,7 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                         random_int(0, 0xFFFF), random_int(0, 0xFFFF));
                 }
 
-                $ent = is_array($fctx->reqdata) ? $fctx->reqdata : [];
+                $ent = self::record($fctx->reqdata);
                 $ent['id'] = $id;
                 $entmap[$id] = $ent;
                 $entity->data[$entname] = $entmap;

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

@@ -78,10 +78,10 @@ class ProjectNameValidateFeature extends ProjectNameBaseFeature
     // Outbound. make_spec short-circuits on a $ctx->out['spec'] that is
     // already set, so assigning the error here rejects the operation before
     // the request is built - the same seam rbac uses one stage earlier.
-    public function PreSpec(ProjectNameContext $ctx): mixed
+    public function PreSpec(ProjectNameContext $ctx): void
     {
         if (!$this->active || !$this->request) {
-            return null;
+            return;
         }
 
         $opname = $this->_opname($ctx);
@@ -90,19 +90,19 @@ class ProjectNameValidateFeature extends ProjectNameBaseFeature
         $opspec = is_array($ops) ? ($ops[$opname] ?? null) : null;
 
         if ($opspec === null) {
-            return null;
+            return;
         }
 
         $errs = $this->_check($ctx, $this->_payload($ctx, $opname), $opspec, 'request');
         if (count($errs) === 0 || $this->mode === 'report') {
-            return null;
+            return;
         }
 
         $entname = $this->_entname($ctx);
         $err = $ctx->make_error('validate_failed',
             "Invalid {$opname} request for entity \"{$entname}\": " . implode('; ', $errs));
         $ctx->out['spec'] = $err;
-        return $err;
+        return;
     }
 
     // Inbound. PreDone rather than PreResult: the records are extracted from
@@ -115,25 +115,25 @@ class ProjectNameValidateFeature extends ProjectNameBaseFeature
     // debug, metrics and telemetry. Those observers therefore record the
     // operation as a success before this hook has looked at it. Activating
     // features as an ORDERED LIST fixes it.
-    public function PreDone(ProjectNameContext $ctx): mixed
+    public function PreDone(ProjectNameContext $ctx): void
     {
         if (!$this->active || !$this->response) {
-            return null;
+            return;
         }
 
         $espec = $this->_entity_spec($ctx);
         if (!is_array($espec)) {
-            return null;
+            return;
         }
 
         $dataspec = $espec['data'] ?? null;
         if ($dataspec === null) {
-            return null;
+            return;
         }
 
         $result = $ctx->result ?? null;
         if ($result === null || $result->resdata === null) {
-            return null;
+            return;
         }
 
         // A list op returns many records and a load returns one; both are
@@ -159,7 +159,7 @@ class ProjectNameValidateFeature extends ProjectNameBaseFeature
         }
 
         if (count($errs) === 0 || $this->mode === 'report') {
-            return null;
+            return;
         }
 
         $entname = $this->_entname($ctx);
@@ -180,7 +180,7 @@ class ProjectNameValidateFeature extends ProjectNameBaseFeature
         // feature had just declared invalid.
         $result->resdata = null;
 
-        return $err;
+        return;
     }
 
     // The payload an operation is about to send.
@@ -214,6 +214,8 @@ class ProjectNameValidateFeature extends ProjectNameBaseFeature
         // custom-action call would be rejected for the one key that made it
         // reachable.
         unset($out['$action']);
+        // Nor is `$body`, the raw request body.
+        unset($out['$body']);
 
         return $out;
     }

package/project/.sdk/tm/php/test/FeatureCorpusTest.php

@@ -29,7 +29,7 @@ class FeatureCorpusTest extends TestCase
     // SDK generated without a listed feature still skips, not fails.
 
     // The standard operation names, in the order the runner prefers them.
-    private const FEATURE_CORPUS_OPS = ['load', 'list', 'create', 'update', 'remove'];
+    private const FEATURE_CORPUS_OPS = ['load', 'list', 'create', 'update', 'patch', 'remove'];
 
     private static function corpus(): array
     {
@@ -286,6 +286,39 @@ class FeatureCorpusTest extends TestCase
         return $client->$prop ?? null;
     }
 
+    // The first feature a case composes that this SDK does not generate,
+    // probed as a section's own feature is. Such a case is skipped rather
+    // than failed.
+    private static function missingFeature(array $kase, array &$have): ?string
+    {
+        $spec = $kase['feature'] ?? null;
+        $names = [];
+        if (is_array($spec) && array_is_list($spec)) {
+            foreach ($spec as $f) {
+                if (is_array($f) && is_string($f['name'] ?? null)) {
+                    $names[] = $f['name'];
+                }
+            }
+        } elseif (is_array($spec)) {
+            $names = array_keys($spec);
+            sort($names);
+        }
+        foreach ($names as $name) {
+            if (!is_string($name)) {
+                continue;
+            }
+            if (!array_key_exists($name, $have)) {
+                $have[$name] = self::present(
+                    self::buildClient(['feature' => [['name' => $name, 'active' => true]]]),
+                    $name);
+            }
+            if (!$have[$name]) {
+                return $name;
+            }
+        }
+        return null;
+    }
+
     public function testCorpusCarriesAFeatureSection(): void
     {
         // A corpus with no `feature` section is a SKIP, not a failure. Each
@@ -323,6 +356,8 @@ class FeatureCorpusTest extends TestCase
                 . 'the corpus (create-sdkgen .sdk/test/feature/) to run these cases');
         }
 
+        $failed = [];
+        $have = [];
         $names = array_keys(self::corpus()['feature'] ?? []);
         sort($names);
         foreach ($names as $name) {
@@ -356,6 +391,16 @@ class FeatureCorpusTest extends TestCase
             foreach ($cases as $raw) {
                 $need = self::tokensUsed($raw);
                 if ($need > count($ops)) {
+                    fwrite(STDERR, sprintf("skip \"%s\": needs %d operations, this SDK offers %d\n",
+                        $raw['name'] ?? '', $need, count($ops)));
+                    continue;
+                }
+
+                $missing = self::missingFeature($raw, $have);
+                if (null !== $missing) {
+                    fwrite(STDERR, sprintf(
+                        "skip \"%s\": needs the %s feature, which this SDK does not generate\n",
+                        $raw['name'] ?? '', $missing));
                     continue;
                 }
 
@@ -364,52 +409,62 @@ class FeatureCorpusTest extends TestCase
                     $tokens['#OP' . ($i + 1)] = $ops[$i]['key'];
                 }
                 $kase = self::resolve($raw, $tokens);
+                $label = (string)($kase['name'] ?? '');
+                $ran++;
 
-                $client = self::buildClient($kase);
-                $label = $kase['name'] ?? '';
-
-                foreach (($kase['op'] ?? []) as $step) {
-                    $op = $byKey[$step['op']] ?? null;
-                    $this->assertNotNull($op, "$label: no operation {$step['op']}");
-                    $ctrl = $step['ctrl'] ?? [];
-                    $wanterr = $step['err'] ?? null;
-
-                    try {
-                        self::invoke($client, $op, $ctrl);
-                        $this->assertNull($wanterr,
-                            "$label: {$step['op']} was expected to fail, and did not");
-                    } catch (\PHPUnit\Framework\AssertionFailedError $e) {
-                        throw $e;
-                    } catch (\Throwable $err) {
-                        $this->assertNotNull($wanterr,
-                            "$label: {$step['op']} failed unexpectedly: " . $err->getMessage());
-                        if (is_string($wanterr)) {
-                            // The CODE, not the message: make_error prefixes
-                            // and humanises the text, so matching it would
-                            // pass on any error that mentioned the word.
-                            //
-                            // `sdk_code`, not `code`: Exception::$code is a
-                            // protected int on every PHP throwable, so the
-                            // SDK carries its own string code beside it.
-                            $code = property_exists($err, 'sdk_code') ? $err->sdk_code : null;
-                            $this->assertSame($wanterr, $code,
-                                "$label: wrong error code (" . $err->getMessage() . ')');
+                // Every failing case is reported, not only the first.
+                try {
+                    $client = self::buildClient($kase);
+
+                    foreach (($kase['op'] ?? []) as $step) {
+                        $op = $byKey[$step['op']] ?? null;
+                        $this->assertNotNull($op, "$label: no operation {$step['op']}");
+                        $ctrl = $step['ctrl'] ?? [];
+                        $wanterr = $step['err'] ?? null;
+
+                        try {
+                            self::invoke($client, $op, $ctrl);
+                            $this->assertNull($wanterr,
+                                "$label: {$step['op']} was expected to fail, and did not");
+                        } catch (\PHPUnit\Framework\AssertionFailedError $e) {
+                            throw $e;
+                        } catch (\Throwable $err) {
+                            $this->assertNotNull($wanterr,
+                                "$label: {$step['op']} failed unexpectedly: " . $err->getMessage());
+                            if (is_string($wanterr)) {
+                                // The CODE, not the message: make_error prefixes
+                                // and humanises the text, so matching it would
+                                // pass on any error that mentioned the word.
+                                //
+                                // `sdk_code`, not `code`: Exception::$code is a
+                                // protected int on every PHP throwable, so the
+                                // SDK carries its own string code beside it.
+                                $code = property_exists($err, 'sdk_code') ? $err->sdk_code : null;
+                                $this->assertSame($wanterr, $code,
+                                    "$label: wrong error code (" . $err->getMessage() . ')');
+                            }
                         }
                     }
-                }
 
-                $this->subset(self::record($client, $name), $kase['out'] ?? [],
-                    "$label: _$name");
-                $ran++;
+                    $this->subset(self::record($client, $name), $kase['out'] ?? [],
+                        "$label: _$name");
+                } catch (\Throwable $e) {
+                    $msg = $e->getMessage();
+                    $failed[] = str_starts_with($msg, $label) ? $msg : "$label: $msg";
+                }
             }
 
-            $this->assertGreaterThan(0, $ran, "every feature.$name case was skipped");
             // Say how many ran. A partial run is legitimate (an SDK with one
             // operation skips the cases needing two) but it should be visible
             // rather than inferred from a green tick.
             fwrite(STDERR, sprintf(
                 "feature.%s: ran %d of %d case(s) against %d operation(s)\n",
                 $name, $ran, count($cases), count($ops)));
+            if (0 === $ran) {
+                $failed[] = "every feature.$name case was skipped";
+            }
         }
+
+        $this->assertSame([], $failed, count($failed) . ' feature corpus case(s) failed');
     }
 }

package/project/.sdk/tm/php/test/FeatureTest.php

@@ -13,10 +13,9 @@ declare(strict_types=1);
 // with no live server and no API-specific fixtures. Mirrors
 // tm/ts/test/feature.test.ts + tm/ts/test/feature/harness.ts.
 //
-// Note: the generated PHP pipeline dispatches PrePoint..PreDone; the
-// PreUnexpected hook is dispatched here by the harness failure path (the
-// real pipeline raises via make_error before a PreUnexpected dispatch
-// point), which keeps the features' emit-once semantics covered.
+// Note: the harness failure path dispatches PreUnexpected, as make_error
+// and an operation's catch path do in the real pipeline, which keeps the
+// features' emit-once semantics covered.
 
 require_once __DIR__ . '/../projectname_sdk.php';
 
@@ -232,7 +231,7 @@ class FtHarness
         if ($op === 'create') {
             return 'POST';
         }
-        if ($op === 'update') {
+        if ($op === 'update' || $op === 'patch') {
             return 'PATCH';
         }
         if ($op === 'remove') {

package/project/.sdk/tm/php/test/PipelineTest.php

@@ -117,6 +117,20 @@ class PipelineTest extends TestCase
         return ($err instanceof ProjectNameError) ? $err->sdk_code : '';
     }
 
+    // An object is a map to the struct port, so it is a map to a cookie
+    // argument: its properties go out as pairs, read through the port.
+    public function test_prepare_headers_cookie_object(): void
+    {
+        $utility = self::utility();
+        $ctx = self::ctx([
+            'utility' => $utility,
+            'point' => ['args' => ['cookie' => [['name' => 'prefs', 'orig' => 'prefs', 'kind' => 'cookie']]]],
+            'reqmatch' => ['prefs' => (object) ['size' => 2, 'lang' => 'en gb']],
+        ]);
+        $headers = ($utility->prepare_headers)($ctx);
+        $this->assertSame('lang=en%20gb; size=2', $headers['cookie'] ?? null);
+    }
+
 
     // --- feature order (feature #2) -----------------------------------------
     // options['feature'] accepts an ordered LIST (developer add-order) or a map
@@ -750,7 +764,10 @@ class PipelineTest extends TestCase
         if ('' !== $cred['pair']) {
             // A cookie credential is a `<scheme>=<key>` pair, and the scheme
             // name leaves no room for the option's prefix.
-            $this->assertMatchesRegularExpression(self::COOKIE_PAIR, $cred['value']);
+            // preg_match rather than assertMatchesRegularExpression, which
+            // PHPUnit 8 does not have.
+            $this->assertSame(1, preg_match(self::COOKIE_PAIR, (string) $cred['value']),
+                (string) $cred['value']);
             return;
         }
         // A header credential is prefix-joined; a query credential is the raw

package/project/.sdk/tm/php/test/Runner.php

@@ -184,6 +184,92 @@ class ProjectNameTestRunner
         }
         return 500;
     }
+
+    /**
+     * A live check that did not pass, as main.kit.test.live.strict decides:
+     * strict fails the test, lenient skips it with the same reason.
+     */
+    public static function live_miss(bool $strict, string $reason): void
+    {
+        if ($strict) {
+            \PHPUnit\Framework\Assert::fail($reason);
+        }
+        \PHPUnit\Framework\Assert::markTestSkipped($reason);
+    }
+
+    /** An account holding no record for the test to read skips either way. */
+    public static function live_empty(string $reason): void
+    {
+        \PHPUnit\Framework\Assert::markTestSkipped($reason);
+    }
+
+    /** A live list response's records: the body, or the first list an envelope holds. */
+    public static function live_list($data): ?array
+    {
+        if (is_array($data) && array_is_list($data)) {
+            return $data;
+        }
+        if (is_array($data)) {
+            foreach ($data as $value) {
+                if (is_array($value) && array_is_list($value)) {
+                    return $value;
+                }
+            }
+        }
+        return null;
+    }
+
+    /** A live response for a message: the SDK's error, or its status and content type. */
+    public static function live_describe(array $result): string
+    {
+        $err = $result["err"] ?? null;
+        if ($err instanceof \Throwable) {
+            return $err->getMessage();
+        }
+        if (!empty($err)) {
+            return is_string($err) ? $err : json_encode($err);
+        }
+        $type = null;
+        foreach (($result["headers"] ?? []) as $k => $v) {
+            if (strtolower((string)$k) === "content-type") {
+                $type = trim(explode(";", (string)$v)[0]);
+            }
+        }
+        return "HTTP " . ($result["status"] ?? "none") . ($type ? " " . $type : "");
+    }
+
+    /**
+     * The record a create-less flow reads live: the first its list returns,
+     * put where the flow reads the fixture's existing records.
+     */
+    public static function live_existing(array &$setup, bool $strict, string $name, callable $list): void
+    {
+        $found = null;
+        try {
+            $found = $list();
+        } catch (\Throwable $e) {
+            self::live_miss($strict, "Live list discovery failed: " . $e->getMessage());
+        }
+        if (!is_array($found)) {
+            self::live_miss($strict, "Live list discovery returned no list");
+        }
+        if (0 === count($found)) {
+            self::live_empty("The account has no $name record to load");
+        }
+        $first = $found[0];
+        $setup["data"]["existing"][$name] = [
+            "live01" => (is_object($first) && method_exists($first, 'data_get')) ? $first->data_get() : $first,
+        ];
+    }
+
+    /** In a lenient live run a failing check skips, observing the live API. */
+    public static function live_observe(\Throwable $e, array $setup, bool $strict): void
+    {
+        if ($strict || empty($setup["live"]) || $e instanceof \PHPUnit\Framework\SkippedTest) {
+            throw $e;
+        }
+        \PHPUnit\Framework\Assert::markTestSkipped("live run, main.kit.test.live.strict is false: " . $e->getMessage());
+    }
 }
 
 // Aliases for test convenience.

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

@@ -99,26 +99,31 @@ class ProjectNameClean
 
     // A feature's name is not a field name: only the sensitive names inside
     // its settings count, so `secrets` does not make every setting a secret.
-    // Entity blocks (per-entity settings, seeded records) hold no credential.
+    // Entity blocks (per-entity settings, seeded records) hold no credential,
+    // and nor do rbac's rules, keyed by entity and operation names.
     public static function add_options(?ProjectNameContext $ctx, array $opts): void
     {
         $feature = $opts['feature'] ?? null;
         unset($opts['feature'], $opts['entity']);
         if (array_key_exists('test', $opts)) {
-            $opts['test'] = self::no_entity($opts['test']);
+            $opts['test'] = self::plain_settings($opts['test'], null);
         }
         self::add_sensitive($ctx, $opts);
         $feature = is_object($feature) ? get_object_vars($feature) : $feature;
-        foreach (is_array($feature) ? $feature : [$feature] as $fopts) {
-            self::add_sensitive($ctx, self::no_entity($fopts));
+        foreach (is_array($feature) ? $feature : [$feature] as $fname => $fopts) {
+            self::add_sensitive($ctx, self::plain_settings($fopts, is_string($fname) ? $fname : null));
         }
     }
 
-    private static function no_entity(mixed $block): mixed
+    private static function plain_settings(mixed $block, ?string $name): mixed
     {
         $block = is_object($block) ? get_object_vars($block) : $block;
         if (is_array($block)) {
+            $name ??= is_string($block['name'] ?? null) ? $block['name'] : null;
             unset($block['entity']);
+            if ('rbac' === $name) {
+                unset($block['rules']);
+            }
         }
         return $block;
     }