@voxgig/sdkgen 4.23.0 → 4.24.1

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

@@ -15,16 +15,26 @@ package ProjectNameUtilities;
 
 our %REGISTRY;
 
+# `$action` selects the point (see make_point); it is never an API field, so
+# the body is a copy without it. The caller's hash is left untouched.
+my $strip_action = sub {
+  my ($reqdata) = @_;
+  return $reqdata unless 'HASH' eq ref $reqdata && exists $reqdata->{'$action'};
+  my %body = %$reqdata;
+  delete $body{'$action'};
+  return \%body;
+};
+
 $REGISTRY{transform_request} = sub {
   my ($ctx) = @_;
   my $spec = $ctx->{spec};
   my $point = $ctx->{point};
   $spec->{step} = 'reqform' if $spec;
   my $transform = ProjectNameHelpers::to_map(ProjectNameHelpers::gp($point, 'transform'));
-  return $ctx->{reqdata} unless $transform;
+  return $strip_action->($ctx->{reqdata}) unless $transform;
   my $reqform = ProjectNameHelpers::gp($transform, 'req');
-  return $ctx->{reqdata} unless ProjectNameHelpers::rb_truthy($reqform);
-  return Voxgig::Struct::transform({ 'reqdata' => $ctx->{reqdata} }, $reqform);
+  return $strip_action->($ctx->{reqdata}) unless ProjectNameHelpers::rb_truthy($reqform);
+  return $strip_action->(Voxgig::Struct::transform({ 'reqdata' => $ctx->{reqdata} }, $reqform));
 };
 
 1;

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

@@ -55,7 +55,11 @@ class ProjectNameContext
             if (array_key_exists('actor', $ctrl_raw)) {
                 $this->ctrl->actor = $ctrl_raw['actor'];
             }
-        } elseif ($basectx !== null && $basectx->ctrl !== null) {
+            if (isset($ctrl_raw['paging']) && is_array($ctrl_raw['paging'])) {
+                $this->ctrl->paging = $ctrl_raw['paging'];
+            }
+        } elseif ($basectx !== null && $basectx->ctrl !== null
+            && ProjectNameHelpers::get_ctx_prop($ctxmap, "opname") === null) {
             $this->ctrl = $basectx->ctrl;
         }
 

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

@@ -21,11 +21,16 @@ class ProjectNameControl
     // passed. The shared feature corpus caught it.
     public mixed $actor;
 
+    // Per-call paging record: read by the paging feature before the request
+    // and written back after it. Declared for the same reason as `$actor`.
+    public mixed $paging;
+
     public function __construct(array $opts = [])
     {
         $this->throw_err = $opts['throw_err'] ?? null;
         $this->err = null;
         $this->explain = $opts['explain'] ?? null;
         $this->actor = $opts['actor'] ?? null;
+        $this->paging = $opts['paging'] ?? null;
     }
 }

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

@@ -9,8 +9,8 @@ require_once __DIR__ . '/BaseFeature.php';
 // stamps page/limit (or a cursor) into the request query; on the way back
 // (PreResult) it reads the server's pagination signals — a `Link:
 // rel="next"` header, `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body — and records
-// them on `$ctx->result->paging`. A per-call `ctrl->paging` (page or
+// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case
+// forms too) — and records them on `$ctx->result->paging` and `ctrl->paging`. A per-call `ctrl->paging` (page or
 // cursor) takes priority over the stamped defaults; parameter names and
 // page size are configurable; `startPage` defaults to 1. Mirrors
 // ts/src/feature/paging/PagingFeature.ts.
@@ -71,8 +71,10 @@ class ProjectNamePagingFeature extends ProjectNameBaseFeature
         } elseif (($spec->query[$page_param] ?? null) === null) {
             $start_page = is_numeric($this->options['startPage'] ?? null)
                 ? $this->options['startPage'] : 1;
-            $spec->query[$page_param] = ($paging['page'] ?? null) !== null
-                ? $paging['page'] : $start_page;
+            // A record written back by PreResult holds the page just fetched
+            // as "page" and the one to fetch as "nextPage", so nextPage wins.
+            $page = $paging['nextPage'] ?? $paging['page'] ?? null;
+            $spec->query[$page_param] = $page !== null ? $page : $start_page;
         }
 
         if (($this->options['limit'] ?? null) !== null
@@ -194,17 +196,30 @@ class ProjectNamePagingFeature extends ProjectNameBaseFeature
             }
         }
 
-        // Body-level cursors.
+        // Body-level signals; snake_case forms are read first so camelCase wins.
         if (is_array($body)) {
             if (($body['next'] ?? null) !== null) {
                 $paging['next'] = $paging['next'] ?? $body['next'];
             }
+            if (($body['next_cursor'] ?? null) !== null) {
+                $paging['cursor'] = $body['next_cursor'];
+            }
             if (($body['cursor'] ?? null) !== null) {
                 $paging['cursor'] = $body['cursor'];
             }
             if (($body['nextCursor'] ?? null) !== null) {
                 $paging['cursor'] = $body['nextCursor'];
             }
+            if ($paging['nextPage'] === null) {
+                $np = $body['nextPage'] ?? $body['next_page'] ?? null;
+                if (is_int($np) || is_float($np) || is_string($np)) {
+                    $paging['nextPage'] = $np;
+                }
+            }
+            if (is_bool($body['has_more'] ?? null)) {
+                $paging['hasMore'] = $body['has_more'];
+                $explicit_more = true;
+            }
             if (is_bool($body['hasMore'] ?? null)) {
                 $paging['hasMore'] = $body['hasMore'];
                 $explicit_more = true;
@@ -225,6 +240,12 @@ class ProjectNamePagingFeature extends ProjectNameBaseFeature
 
         $result->paging = $paging;
 
+        // PHP arrays are values, so the record lands on this call's Control
+        // rather than on an array the caller passed.
+        if ($ctx->ctrl !== null) {
+            $ctx->ctrl->paging = $paging;
+        }
+
         $this->client->_paging = ['last' => $paging];
     }
 

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

@@ -35,8 +35,8 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
 
         $this->client->mode = 'test';
 
-        // Ensure entity ids are correct.
-        \Voxgig\Struct\Struct::walk($entity_data, function ($key, $val, $parent, $path) {
+        // Ensure entity ids are correct (walk is by value: keep its result).
+        $entity_data = \Voxgig\Struct\Struct::walk($entity_data, function ($key, $val, $parent, $path) {
             if (count($path) === 2 && is_array($val) && $key !== null) {
                 $val['id'] = $key;
             }
@@ -103,9 +103,8 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
 
             // PHP-portable equivalent of TS buildArgs+select: a flat-key
             // filter that matches by exact-equality on each provided key,
-            // with alias fallback. Empty match matches all entries — load
-            // with empty match returns the first fixture entry (or last
-            // create), list returns all entries.
+            // with alias fallback. An empty match matches every entry, as an
+            // empty `$AND` does in select; a non-empty miss matches nothing.
             $find_first = function (array $entmap, $match, $alias) {
                 if (!is_array($match) || empty($match)) {
                     foreach ($entmap as $e) {
@@ -158,6 +157,23 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
 
             $alias = is_object($op) ? ($op->alias ?? null) : \Voxgig\Struct\Struct::getprop($op, 'alias');
 
+            // Every op filters through buildArgs, which keeps `id` and the
+            // point's required params and drops the rest. find_first/find_all
+            // take a flat map, so take the primary key of each $OR clause;
+            // they do their own alias fallback.
+            $query_match = function ($args) use ($fctx, $op) {
+                $flat = [];
+                foreach (($this->buildArgs($fctx, $op, $args)['$AND'] ?? []) as $clause) {
+                    $ors = $clause['$OR'] ?? [];
+                    if (is_array($ors) && count($ors) > 0 && is_array($ors[0])) {
+                        foreach ($ors[0] as $lk => $lv) {
+                            $flat[$lk] = $lv;
+                        }
+                    }
+                }
+                return $flat;
+            };
+
             // 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 (carried in $fctx->match / $fctx->data). This
@@ -176,7 +192,7 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
             };
 
             if ($op->name === 'load') {
-                $ent = $find_first($entmap, $resolve_match($fctx->reqmatch), $alias);
+                $ent = $find_first($entmap, $query_match($resolve_match($fctx->reqmatch)), $alias);
                 if ($ent === null) {
                     return $respond(404, null, ['statusText' => 'Not found']);
                 }
@@ -185,37 +201,7 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                 return $respond(200, $out);
 
             } elseif ($op->name === 'list') {
-                // FILTER THE MATCH THE WAY THE TS MOCK DOES.
-                //
-                // This branch used the whole of reqmatch, while load goes
-                // through resolve_match and the TS mock runs every op through
-                // buildArgs — which keeps `id` and the point's REQUIRED params
-                // and drops the rest. buildArgs is right here in this file and
-                // its docblock says it mirrors the TS one; list simply did not
-                // call it.
-                //
-                // So a match key that is neither `id` nor a required route
-                // param matched NOTHING in php and was IGNORED in ts. trello's
-                // board_star lists on `board_id`, which is not a field of that
-                // entity (id, pos, member_id, id_board) and not a route param:
-                // php returned an empty list and BoardStarEntityTest failed on
-                // an assertion that ts, js and every other port passed.
-                //
-                // buildArgs returns a struct query; find_all takes a flat map,
-                // so take the primary key of each $OR clause. find_all already
-                // does its own alias fallback, which is what the second $OR
-                // element carries.
-                $listargs = $this->buildArgs($fctx, $op, $fctx->reqmatch);
-                $listmatch = [];
-                foreach (($listargs['$AND'] ?? []) as $clause) {
-                    $ors = $clause['$OR'] ?? [];
-                    if (is_array($ors) && count($ors) > 0 && is_array($ors[0])) {
-                        foreach ($ors[0] as $lk => $lv) {
-                            $listmatch[$lk] = $lv;
-                        }
-                    }
-                }
-                $found = $find_all($entmap, $listmatch, $alias);
+                $found = $find_all($entmap, $query_match($fctx->reqmatch), $alias);
                 $cleaned = [];
                 foreach ($found as $e) {
                     if (is_array($e)) unset($e['$KEY']);
@@ -245,14 +231,13 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                 if (empty($update_match)) {
                     $update_match = $resolve_match([]);
                 }
-                $ent = $find_first($entmap, $update_match, $alias);
+                $ent = $find_first($entmap, $query_match($update_match), $alias);
                 if ($ent === null) {
+                    // update miss: 404, never another record
                     return $respond(404, null, ['statusText' => 'Not found']);
                 }
                 if (is_array($fctx->reqdata)) {
-                    foreach ($fctx->reqdata as $k => $v) {
-                        $ent[$k] = $v;
-                    }
+                    $ent = \Voxgig\Struct\Struct::merge([$ent, $fctx->reqdata]);
                 }
                 $id = is_array($ent) ? ($ent['id'] ?? null) : null;
                 if ($id !== null) {
@@ -264,7 +249,7 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
                 return $respond(200, $out);
 
             } elseif ($op->name === 'remove') {
-                $ent = $find_first($entmap, $resolve_match($fctx->reqmatch), $alias);
+                $ent = $find_first($entmap, $query_match($resolve_match($fctx->reqmatch)), $alias);
                 // Remove only the first matched entity. If nothing matches,
                 // succeed as a no-op rather than erroring.
                 $id = is_array($ent) ? ($ent['id'] ?? null) : null;

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

@@ -267,6 +267,19 @@ class FeatureCorpusTest extends TestCase
         $this->assertSame($expect, $actual, $path);
     }
 
+    // Whether the SDK built the feature at all. The activity record is the
+    // wrong probe: most features create theirs on first use, so an idle
+    // client has none and every section but the eager ones read as inert.
+    private static function present($client, string $name): bool
+    {
+        foreach ($client->features ?? [] as $f) {
+            if (($f->name ?? null) === $name) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     private static function record($client, string $name)
     {
         $prop = '_' . $name;
@@ -326,7 +339,10 @@ class FeatureCorpusTest extends TestCase
             // Probed by ACTIVATING it: the feature defaults to inactive, so an
             // idle client never builds it and its absence says nothing.
             $probe = self::buildClient(['feature' => [['name' => $name, 'active' => true]]]);
-            if (null === self::record($probe, $name)) {
+            if (!self::present($probe, $name)) {
+                // The one line every runner prints for an inert section.
+                fwrite(STDERR, sprintf(
+                    "feature.%s: inert (this SDK does not generate the feature)\n", $name));
                 continue;
             }
 

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

@@ -1104,6 +1104,50 @@ class FeatureTest extends TestCase
         $this->assertTrue($res['result']->paging['hasMore']);
     }
 
+    public function test_paging_snake_case_signals_and_ctrl_write_back(): void
+    {
+        $this->needs('paging');
+        $rec = new FtRecorder(function (int $n) {
+            return FtHarness::response(200, 1 === $n
+                ? ['has_more' => true, 'next_cursor' => 'c2']
+                : ['has_more' => false]);
+        });
+        $h = new FtHarness([
+            ['name' => 'paging'],
+        ], $rec->server());
+        $res = $h->op(['op' => 'list', 'path' => '/w', 'ctrl' => ['paging' => []]]);
+        $this->assertTrue($res['result']->paging['hasMore']);
+        $this->assertSame('c2', $res['result']->paging['cursor']);
+        $written = $res['ctx']->ctrl->paging;
+        $this->assertSame('c2', $written['cursor']);
+        $this->assertTrue($written['hasMore']);
+        // Arrays are values here, so the written-back record is passed on by hand.
+        $res = $h->op(['op' => 'list', 'path' => '/w', 'ctrl' => ['paging' => $written]]);
+        $this->assertStringContainsString('cursor=c2', $rec->calls[1]['url']);
+        $this->assertFalse($res['ctx']->ctrl->paging['hasMore']);
+        $this->assertNull($res['ctx']->ctrl->paging['cursor']);
+    }
+
+    public function test_paging_continues_from_written_back_next_page(): void
+    {
+        $this->needs('paging');
+        $rec = new FtRecorder(function (int $n) {
+            return FtHarness::response(200, 1 === $n ? ['next_page' => 2] : [],
+                ['x-page' => (string) $n]);
+        });
+        $h = new FtHarness([
+            ['name' => 'paging'],
+        ], $rec->server());
+        $res = $h->op(['op' => 'list', 'path' => '/w']);
+        $written = $res['ctx']->ctrl->paging;
+        $this->assertEquals(1, $written['page']);
+        $this->assertEquals(2, $written['nextPage']);
+        $this->assertTrue($written['hasMore']);
+        $res = $h->op(['op' => 'list', 'path' => '/w', 'ctrl' => ['paging' => $written]]);
+        $this->assertStringContainsString('page=2', $rec->calls[1]['url']);
+        $this->assertFalse($res['ctx']->ctrl->paging['hasMore']);
+    }
+
     public function test_paging_non_list_op_is_not_paged(): void
     {
         $this->needs('paging');

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

@@ -611,59 +611,176 @@ class PipelineTest extends TestCase
 
     // --- prepare_auth ------------------------------------------------------------
 
-    private static function auth_ctx(array $options, ?array $headers): ProjectNameContext
+    /**
+     * A cookie credential as prepare_auth writes it: `<scheme>=K` for the
+     * probe key, with no scheme prefix and nothing else in the bag.
+     */
+    private const COOKIE_PAIR = '/^[^=;]+=K$/';
+
+    private static function auth_ctx(array $options, ?ProjectNameSpec $spec): ProjectNameContext
     {
         $client = new PlClient($options);
         return self::ctx([
             'client' => $client,
-            'spec' => $headers === null ? null : new ProjectNameSpec(['headers' => $headers]),
+            'spec' => $spec,
+        ]);
+    }
+
+    private static function auth_bags(): ProjectNameSpec
+    {
+        return new ProjectNameSpec(['headers' => [], 'query' => []]);
+    }
+
+    /**
+     * `basic: false` is explicit: an HTTP Basic API's generated config carries
+     * `auth.basic: true`, and a client that merges it in takes a branch that
+     * needs a secret as well. With none supplied that branch deliberately
+     * writes nothing, which the probe would read as a public API.
+     */
+    private static function auth_block(string $prefix): array
+    {
+        return ['prefix' => $prefix, 'basic' => false];
+    }
+
+    /**
+     * Run prepare_auth with both containers present and see which one the
+     * generated utility writes to, and under what name. Null means this SDK
+     * places no credential at all - a public API - which is a legitimate
+     * shape, and the tests below assert exactly that instead. `pair` is the
+     * `<scheme>=` lead-in of a COOKIE credential, which rides the header bag
+     * under the key `cookie` instead of taking a header of its own.
+     *
+     * @return array{where:string,name:string,value:mixed,pair:string}|null
+     */
+    private static function auth_probe(array $options): ?array
+    {
+        $ctx = self::auth_ctx($options, self::auth_bags());
+        ProjectNamePrepareAuth::call($ctx);
+        foreach (['headers', 'query'] as $where) {
+            // A cookie credential rides the header bag, because a cookie IS
+            // a header.
+            $bag = 'query' === $where ? $ctx->spec->query : $ctx->spec->headers;
+            foreach ($bag as $name => $value) {
+                $pair = '';
+                if ('headers' === $where && 'cookie' === $name && is_string($value)
+                    && 1 === preg_match(self::COOKIE_PAIR, $value)) {
+                    $pair = substr($value, 0, -1);
+                }
+                return ['where' => $where, 'name' => $name, 'value' => $value, 'pair' => $pair];
+            }
+        }
+        return null;
+    }
+
+    /** @return array{where:string,name:string,value:mixed,pair:string}|null */
+    private static function auth_credential(): ?array
+    {
+        return self::auth_probe(
+            ['apikey' => 'K', 'auth' => self::auth_block('Bearer')]);
+    }
+
+    /**
+     * Every credential this SDK could possibly place: both credentials and
+     * Basic switched on, so whichever branch the API has, something lands
+     * unless the API is public.
+     *
+     * @return array{where:string,name:string,value:mixed,pair:string}|null
+     */
+    private static function auth_any_credential(): ?array
+    {
+        return self::auth_probe([
+            'apikey' => 'K', 'secret' => 'S',
+            'auth' => ['prefix' => 'Bearer', 'basic' => true],
         ]);
     }
 
+    /** @return array{0:mixed,1:bool} the value left in the credential slot, and whether it is there */
+    private static function auth_placed(array $options, $seed = null): array
+    {
+        $cred = self::auth_credential();
+        $spec = self::auth_bags();
+        if (null !== $cred && null !== $seed) {
+            if ('query' === $cred['where']) {
+                $spec->query[$cred['name']] = $seed;
+            } else {
+                $spec->headers[$cred['name']] = $seed;
+            }
+        }
+        $ctx = self::auth_ctx($options, $spec);
+        ProjectNamePrepareAuth::call($ctx);
+        if (null === $cred) {
+            return [null, false];
+        }
+        $bag = 'query' === $cred['where'] ? $ctx->spec->query : $ctx->spec->headers;
+        return [$bag[$cred['name']] ?? null, array_key_exists($cred['name'], $bag)];
+    }
+
     public function test_prepare_auth_guards_a_missing_spec(): void
     {
-        $ctx = self::auth_ctx(['auth' => ['prefix' => ''], 'apikey' => 'K'], null);
+        $ctx = self::auth_ctx(['auth' => self::auth_block(''), 'apikey' => 'K'], null);
         [, $err] = ProjectNamePrepareAuth::call($ctx);
         $this->assertSame('auth_no_spec', self::code($err));
     }
 
-    public function test_prepare_auth_an_apikey_with_a_prefix_is_space_joined(): void
+    /**
+     * Without this the cases below cannot fail for an SDK whose credential the
+     * probe misses: every one of them takes the public-API path instead.
+     */
+    public function test_prepare_auth_probe_finds_the_credential_this_sdk_places(): void
     {
-        $ctx = self::auth_ctx(['apikey' => 'K', 'auth' => ['prefix' => 'Bearer']], []);
-        [, $err] = ProjectNamePrepareAuth::call($ctx);
-        $this->assertNull($err);
-        $this->assertSame('Bearer K', $ctx->spec->headers['authorization']);
+        $this->assertSame(
+            null === self::auth_credential(), null === self::auth_any_credential());
+    }
+
+    public function test_prepare_auth_places_the_apikey_where_this_api_puts_it(): void
+    {
+        $cred = self::auth_credential();
+        if (null === $cred) {
+            // A public API places nothing, and that is the whole assertion.
+            [, $has] = self::auth_placed(['apikey' => 'K', 'auth' => self::auth_block('Bearer')]);
+            $this->assertFalse($has);
+            return;
+        }
+        $this->assertContains($cred['where'], ['headers', 'query']);
+        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']);
+            return;
+        }
+        // A header credential is prefix-joined; a query credential is the raw
+        // key, because a query parameter has nowhere to put a scheme name.
+        $this->assertSame('query' === $cred['where'] ? 'K' : 'Bearer K', $cred['value']);
     }
 
     public function test_prepare_auth_a_raw_apikey_goes_in_as_is(): void
     {
-        $ctx = self::auth_ctx(['apikey' => 'K', 'auth' => ['prefix' => '']], []);
-        ProjectNamePrepareAuth::call($ctx);
-        $this->assertSame('K', $ctx->spec->headers['authorization']);
+        [$value, $has] = self::auth_placed(['apikey' => 'K', 'auth' => self::auth_block('')]);
+        $cred = self::auth_credential();
+        if (null === $cred) {
+            $this->assertFalse($has);
+            return;
+        }
+        $this->assertSame($cred['pair'] . 'K', $value);
     }
 
-    public function test_prepare_auth_an_empty_apikey_drops_the_header(): void
+    public function test_prepare_auth_an_empty_apikey_drops_the_credential(): void
     {
-        $ctx = self::auth_ctx(
-            ['apikey' => '', 'auth' => ['prefix' => 'Bearer']],
-            ['authorization' => 'stale']
-        );
-        ProjectNamePrepareAuth::call($ctx);
-        $this->assertArrayNotHasKey('authorization', $ctx->spec->headers);
+        [, $has] = self::auth_placed(
+            ['apikey' => '', 'auth' => self::auth_block('Bearer')], 'stale');
+        $this->assertFalse($has);
     }
 
-    public function test_prepare_auth_a_public_api_drops_the_header(): void
+    public function test_prepare_auth_a_public_api_drops_the_credential(): void
     {
-        $ctx = self::auth_ctx(['apikey' => 'K'], ['authorization' => 'stale']);
-        ProjectNamePrepareAuth::call($ctx);
-        $this->assertArrayNotHasKey('authorization', $ctx->spec->headers);
+        [, $has] = self::auth_placed(['apikey' => 'K'], 'stale');
+        $this->assertFalse($has);
     }
 
-    public function test_prepare_auth_a_missing_apikey_option_drops_the_header(): void
+    public function test_prepare_auth_a_missing_apikey_option_drops_the_credential(): void
     {
-        $ctx = self::auth_ctx(['auth' => ['prefix' => 'Bearer']], ['authorization' => 'stale']);
-        ProjectNamePrepareAuth::call($ctx);
-        $this->assertArrayNotHasKey('authorization', $ctx->spec->headers);
+        [, $has] = self::auth_placed(['auth' => self::auth_block('Bearer')], 'stale');
+        $this->assertFalse($has);
     }
 
 

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

@@ -70,7 +70,8 @@ class PrimaryUtilityTest extends TestCase
      * `set` used to pass silently, which defeats the point of a shared
      * oracle. EVERY corpus-backed test goes through here (mirrors ts/py).
      */
-    private function runsection(string $name, callable $subject): void
+    private function runsection(
+        string $name, callable $subject, ?callable $adapt = null): void
     {
         $R = self::runpack();
         $spec = $R['spec'];
@@ -89,6 +90,10 @@ class PrimaryUtilityTest extends TestCase
                 "add cases, or mark the fixture PENDING in .sdk/test/primary/");
         }
 
+        if (null !== $adapt) {
+            $basic = $adapt($basic);
+        }
+
         $R['runset']($basic, $subject);
         $this->assertTrue(true, "corpus section '{$name}' completed");
     }
@@ -111,6 +116,66 @@ class PrimaryUtilityTest extends TestCase
         return ($utility->make_context)($ctxmap, $client->get_root_ctx());
     }
 
+    /**
+     * Where this SDK's prepare_auth actually puts the credential: the name is
+     * the API's OWN scheme name, not always `authorization`, so it is
+     * discovered by running prepare_auth once.
+     *
+     * @return array{where:string,name:string}|null
+     */
+    private static function auth_credential(
+        ProjectNameSDK $client,
+        ProjectNameUtility $utility
+    ): ?array {
+        $ctx = self::make_test_ctx($client, $utility);
+        $ctx->spec = new ProjectNameSpec(['headers' => [], 'query' => []]);
+        [, $err] = ($utility->prepare_auth)($ctx);
+        // The DEF setup this client is built from carries `auth.basic: false`,
+        // so the single-token branch runs and there is a credential to find.
+        if ($err !== null) {
+            return null;
+        }
+        foreach (['headers', 'query'] as $where) {
+            // A cookie credential rides the header bag, because a cookie IS
+            // a header.
+            $bag = 'query' === $where ? $ctx->spec->query : $ctx->spec->headers;
+            foreach ($bag as $name => $value) {
+                return ['where' => $where, 'name' => $name];
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Rename the corpus's `headers` bag to the real container, and the
+     * `authorization` key inside it to the real credential name. Applied only
+     * to the prepareAuth section, so real header assertions elsewhere are
+     * untouched.
+     *
+     * @param array{where:string,name:string} $cred
+     */
+    private static function retarget_auth($node, array $cred)
+    {
+        if (!is_array($node)) {
+            return $node;
+        }
+
+        $out = [];
+        foreach ($node as $key => $value) {
+            if ('headers' === $key) {
+                $bag = [];
+                foreach (is_array($value) ? $value : [] as $bagkey => $bagvalue) {
+                    $name = 'authorization' === $bagkey ? $cred['name'] : $bagkey;
+                    $bag[$name] = self::retarget_auth($bagvalue, $cred);
+                }
+                $out[$cred['where']] = $bag;
+            } else {
+                $out[$key] = self::retarget_auth($value, $cred);
+            }
+        }
+        return $out;
+    }
+
     private static function make_test_full_ctx(
         ProjectNameSDK $client,
         ProjectNameUtility $utility
@@ -749,6 +814,19 @@ class PrimaryUtilityTest extends TestCase
         $auth_utility = $auth_client->get_utility();
         $utility = self::client()->get_utility();
 
+        // The corpus writes the credential as `headers.authorization`: a
+        // PLACEHOLDER each runner points at the container and name this API
+        // actually uses.
+        $cred = self::auth_credential($auth_client, $auth_utility);
+        $this->assertIsArray($cred,
+            'prepare_auth placed no credential in headers or query');
+
+        $adapt = ('headers' === $cred['where'] && 'authorization' === $cred['name'])
+            ? null
+            : function (array $basic) use ($cred) {
+                return self::retarget_auth($basic, $cred);
+            };
+
         $this->runsection('prepareAuth', function (array $ctxmap) use ($auth_client, $auth_utility, $utility) {
             $ctx = ProjectNameOmni::ctx_from_map($ctxmap, $auth_client, $auth_utility);
 
@@ -759,7 +837,7 @@ class PrimaryUtilityTest extends TestCase
                 throw $err;
             }
             return null;
-        });
+        }, $adapt);
     }