@voxgig/sdkgen 4.22.0 → 4.24.0

package/project/.sdk/tm/perl/feature/paging_feature.pm

@@ -4,8 +4,8 @@
 # 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
-# result.paging. A per-call ctrl paging value (page or cursor) takes
+# nextCursor/hasMore fields in the body (snake_case forms too) - and records
+# them on result.paging and the caller's ctrl paging. A per-call ctrl paging value (page or cursor) takes
 # priority. Parameter names ("pageParam", "limitParam", "cursorParam"),
 # "startPage" (default 1) and page size ("limit") are configurable.
 
@@ -76,8 +76,11 @@ sub PreRequest {
     $spec->{query}{$cursor_param} = $paging->{cursor};
   }
   elsif (!defined $spec->{query}{$page_param}) {
-    $spec->{query}{$page_param} = defined $paging->{page}
-      ? $paging->{page}
+    # A record written back by PreResult holds the page just fetched as
+    # "page" and the one to fetch as "nextPage", so nextPage wins.
+    my $page = defined $paging->{nextPage} ? $paging->{nextPage} : $paging->{page};
+    $spec->{query}{$page_param} = defined $page
+      ? $page
       : (defined $self->{options}{startPage} ? $self->{options}{startPage} : 1);
   }
 
@@ -186,15 +189,27 @@ sub PreResult {
     }
   }
 
-  # Body-level cursors.
+  # Body-level signals; snake_case forms are read first so camelCase wins.
   if (Voxgig::Struct::ismap($body)) {
     my $bnext = ProjectNameHelpers::gp($body, 'next');
     $paging->{next} = defined $paging->{next} ? $paging->{next} : $bnext
       if defined $bnext;
+    my $bsnakecursor = ProjectNameHelpers::gp($body, 'next_cursor');
+    $paging->{cursor} = $bsnakecursor if defined $bsnakecursor;
     my $bcursor = ProjectNameHelpers::gp($body, 'cursor');
     $paging->{cursor} = $bcursor if defined $bcursor;
     my $bnextcursor = ProjectNameHelpers::gp($body, 'nextCursor');
     $paging->{cursor} = $bnextcursor if defined $bnextcursor;
+    unless (defined $paging->{nextPage}) {
+      my $np = ProjectNameHelpers::gp($body, 'nextPage');
+      $np = ProjectNameHelpers::gp($body, 'next_page') unless defined $np;
+      $paging->{nextPage} = $np if defined $np && !ref($np);
+    }
+    my $bsnakemore = $body->{has_more};
+    if (ProjectNameHelpers::is_true($bsnakemore) || ProjectNameHelpers::is_false($bsnakemore)) {
+      $paging->{hasMore} = ProjectNameHelpers::is_true($bsnakemore) ? 1 : 0;
+      $explicit_more = 1;
+    }
     my $bhasmore = $body->{hasMore};
     if (ProjectNameHelpers::is_true($bhasmore) || ProjectNameHelpers::is_false($bhasmore)) {
       $paging->{hasMore} = ProjectNameHelpers::is_true($bhasmore) ? 1 : 0;
@@ -215,6 +230,17 @@ sub PreResult {
 
   $result->{paging} = $paging;
 
+  if ($ctx->{ctrl}) {
+    # The Context shares the caller's paging hash by reference, so refill it
+    # in place; a fresh hash on ctrl never reaches the caller.
+    if (Voxgig::Struct::ismap($ctx->{ctrl}{paging})) {
+      %{ $ctx->{ctrl}{paging} } = %$paging;
+    }
+    else {
+      $ctx->{ctrl}{paging} = $paging;
+    }
+  }
+
   $self->{client}{_paging} = { 'last' => $paging };
   return;
 }

package/project/.sdk/tm/perl/feature/test_feature.pm

@@ -66,10 +66,12 @@ sub init {
     my $tm = ProjectNameHelpers::gp($fctx->{point}, 'transform');
     my $spec = ProjectNameHelpers::gp($tm, 'res');
     return $data unless defined $spec && !ref($spec);
-    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    # synthesise, so it is left alone rather than guessed at.
-    return $data unless $spec =~ /^`body\.([^`.]+)`$/;
-    return { $1 => $data };
+    # Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    # GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
+    return $data unless $spec =~ /^`body\.(.+)`$/;
+    my $out = $data;
+    $out = { $_ => $out } for reverse split /\./, $1, -1;
+    return $out;
   };
 
   my $respond = sub {
@@ -152,18 +154,11 @@ sub init {
       my $args = $test_self->build_args($fctx, $op, $update_match);
       my $found = Voxgig::Struct::select($entmap, $args);
       my $ent = ProjectNameHelpers::ge($found, 0);
-      if (!defined $ent && Voxgig::Struct::ismap($entmap) && keys %$entmap) {
-        for my $k (sort keys %$entmap) {
-          if (Voxgig::Struct::ismap($entmap->{$k})) {
-            $ent = $entmap->{$k};
-            last;
-          }
-        }
-      }
+      # update miss: 404, never another record
       return $respond->($fctx, 404, undef, { 'statusText' => 'Not found' })
         unless ProjectNameHelpers::rb_truthy($ent);
-      if (Voxgig::Struct::ismap($ent) && $fctx->{reqdata}) {
-        $ent->{$_} = $fctx->{reqdata}{$_} for keys %{ $fctx->{reqdata} };
+      if (Voxgig::Struct::ismap($ent) && Voxgig::Struct::ismap($fctx->{reqdata})) {
+        Voxgig::Struct::merge([$ent, $fctx->{reqdata}]);
       }
       Voxgig::Struct::delprop($ent, '$KEY');
       my $out = Voxgig::Struct::clone($ent);
@@ -288,18 +283,55 @@ sub make_netsim {
   };
 }
 
+sub _point_terminal {
+  my ($p) = @_;
+  my $parts = ProjectNameHelpers::gp($p, 'parts');
+  return 0 unless Voxgig::Struct::islist($parts) && @$parts;
+  my $last = $parts->[-1];
+  return (defined $last && !ref $last && 0 == index($last, '{')) ? 1 : 0;
+}
+
+sub _point_depth {
+  my ($p) = @_;
+  my $parts = ProjectNameHelpers::gp($p, 'parts');
+  return Voxgig::Struct::islist($parts) ? scalar @$parts : 0;
+}
+
+# The entity's own endpoint: a terminal `{param}` marks a record route, and
+# among equals the shallower path wins (the same rule as make_point).
+sub _pick_point {
+  my ($points) = @_;
+  return undef unless Voxgig::Struct::islist($points) && @$points;
+  my $point = $points->[0];
+  for my $cand (@$points[1 .. $#$points]) {
+    if (_point_terminal($cand) != _point_terminal($point)) {
+      $point = $cand if _point_terminal($cand);
+    }
+    elsif (_point_depth($cand) < _point_depth($point)) {
+      $point = $cand;
+    }
+  }
+  return $point;
+}
+
 sub build_args {
   my ($self, $ctx, $op, $args) = @_;
   my $opname = $op->{name};
   my $entname = $ctx->{entity}->get_name;
   my $points = ProjectNameHelpers::gpath($ctx->{config},
     "entity.$entname.op.$opname.points");
-  my $point = ProjectNameHelpers::ge($points, -1);
-
-  my $params_path = ProjectNameHelpers::gpath($point, 'args.params');
-  my $reqd_params = Voxgig::Struct::select($params_path,
-    { 'reqd' => Voxgig::Struct::JTRUE() });
-  my $reqd = Voxgig::Struct::transform($reqd_params, ['`$EACH`', '', '`$KEY.name`']);
+  my $point = _pick_point($points);
+
+  # Path AND query: a path-only read misses a query-addressed record
+  # (e.g. GET /result?trace_id=), which has no path param at all.
+  my $reqd = [];
+  for my $kind ('params', 'query') {
+    my $args_path = ProjectNameHelpers::gpath($point, "args.$kind");
+    my $reqd_args = Voxgig::Struct::select($args_path,
+      { 'reqd' => Voxgig::Struct::JTRUE() });
+    my $names = Voxgig::Struct::transform($reqd_args, ['`$EACH`', '', '`$KEY.name`']);
+    push @$reqd, @$names if Voxgig::Struct::islist($names);
+  }
 
   my $qand = [];
   my $q = { '`$AND`' => $qand };

package/project/.sdk/tm/perl/feature/timeout_feature.pm

@@ -3,9 +3,11 @@
 # Per-request timeout. Wraps the active transport with a deadline of "ms"
 # milliseconds (default 30000; <= 0 disables). The transport is synchronous
 # (HTTP::Tiny), so a hanging request is interrupted with a SIGALRM timer
-# (Time::HiRes::ualarm); when an injectable "now" clock is supplied the
-# elapsed wall-clock time is checked instead, so tests can assert the
-# deadline deterministically. Expiry yields an error with code "timeout".
+# (Time::HiRes::ualarm) where the platform has one; where it has none
+# (Windows) the deadline is checked once the call returns. When an
+# injectable "now" clock is supplied the elapsed clock time is checked
+# instead, so tests can assert the deadline deterministically. Expiry
+# yields an error with code "timeout".
 
 use strict;
 use warnings;
@@ -75,24 +77,26 @@ sub with_timeout {
   # Live path: interrupt a hanging synchronous transport.
   my ($res, $err);
   my $timed_out = 0;
-  my $ok = do {
-    local $SIG{ALRM} = sub { $timed_out = 1; die "ProjectNameTimeout\n" };
-    eval {
-      Time::HiRes::ualarm(int($ms * 1000));
-      ($res, $err) = $inner->($ctx, $url, $fetchdef);
-      Time::HiRes::ualarm(0);
-      1;
-    };
+  my $start = Time::HiRes::time();
+  local $SIG{ALRM} = sub { $timed_out = 1; die "ProjectNameTimeout\n" };
+  my $armed = eval { Time::HiRes::ualarm(int($ms * 1000)); 1 };
+  my $ok = eval {
+    ($res, $err) = $inner->($ctx, $url, $fetchdef);
+    1;
   };
-  Time::HiRes::ualarm(0);
+  my $e = $@;
+  eval { Time::HiRes::ualarm(0) } if $armed;
   if (!$ok) {
-    my $e = $@;
     if ($timed_out) {
       $self->_track($ctx, $ms);
       return (undef, $ctx->make_error('timeout', "Request exceeded timeout of ${ms}ms"));
     }
     die $e;
   }
+  if (!$armed && (Time::HiRes::time() - $start) * 1000 > $ms) {
+    $self->_track($ctx, $ms);
+    return (undef, $ctx->make_error('timeout', "Request exceeded timeout of ${ms}ms"));
+  }
   return ($res, $err);
 }
 

package/project/.sdk/tm/perl/t/feature_corpus.t

@@ -267,6 +267,15 @@ sub subset {
 }
 
 
+# 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.
+sub present {
+  my ($client, $name) = @_;
+  return scalar grep { ref $_ && ($_->{name} // '') eq $name }
+    @{ $client->{features} || [] };
+}
+
 sub record {
   my ($client, $name) = @_;
   return $client->{"_$name"};
@@ -295,7 +304,11 @@ for my $name (sort keys %{ $CORPUS->{feature} || {} }) {
   # Probed by ACTIVATING it: the feature defaults to inactive, so an idle
   # client never builds it and its absence says nothing.
   my $probe = build_client({ feature => [ { name => $name, active => 1 } ] });
-  next unless defined record($probe, $name);
+  unless (present($probe, $name)) {
+    # The one line every runner prints for an inert section.
+    diag("feature.$name: inert (this SDK does not generate the feature)");
+    next;
+  }
 
   my %by_key = map { $_->{key} => $_ } @ops;
 

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

@@ -16,6 +16,16 @@ package ProjectNameUtilities;
 
 our %REGISTRY;
 
+# One HTTP::Tiny per (proxy, redirect) setting: a client keeps its
+# connection alive between requests, so one per request reused nothing.
+my %HTTP_CLIENTS;
+
+sub _http_client {
+  my (%new_args) = @_;
+  my $key = join "\n", map { "$_=$new_args{$_}" } sort keys %new_args;
+  return $HTTP_CLIENTS{$key} //= HTTP::Tiny->new(%new_args);
+}
+
 our $DefaultHttpFetch = sub {
   my ($fullurl, $fetchdef) = @_;
   $fetchdef = {} unless defined $fetchdef;
@@ -47,8 +57,12 @@ our $DefaultHttpFetch = sub {
   $new_args{max_redirect} = 0
     if defined $fetchdef->{redirect} && !ref $fetchdef->{redirect}
       && 'manual' eq $fetchdef->{redirect};
+  # Both keys: HTTP::Tiny lets the environment override its generic proxy.
+  $new_args{http_proxy} = $new_args{https_proxy} = "$fetchdef->{proxy}"
+    if defined $fetchdef->{proxy} && !ref $fetchdef->{proxy}
+      && length $fetchdef->{proxy};
 
-  my $res = eval { HTTP::Tiny->new(%new_args)->request($method, $fullurl, $opts) };
+  my $res = eval { _http_client(%new_args)->request($method, $fullurl, $opts) };
   if (!$res) {
     my $e = defined $@ ? "$@" : 'request failed';
     $e =~ s/\s+\z//;

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

@@ -30,6 +30,7 @@ $REGISTRY{prepare_query} = sub {
     for my $item (@$items) {
       my ($key, $val) = @$item;
       next unless ProjectNameHelpers::rb_truthy($val) && defined $key && !ref $key;
+      next if '$action' eq $key;
       next if grep { defined $_ && !ref $_ && $_ eq $key } @$params;
       $out->{$key} = $val;
     }

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');