@voxgig/sdkgen 4.22.0 → 4.24.0

package/project/.sdk/tm/c/feature/paging.c

@@ -3,7 +3,8 @@
 // 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 cursor/page
+// in the body (snake_case forms too) — and records them on `result.paging`
+// and the caller's ctrl paging. A per-call cursor/page
 // from ctrl takes priority (used by auto-iteration). Parameter names
 // (`pageParam`, `limitParam`, `cursorParam`), the page size (`limit`) and
 // the start page (`startPage`, default 1) are configurable.
@@ -225,7 +226,10 @@ static void paging_pre_request(PagingFeature* pf, Context* ctx) {
   if (!v_is_noval(cursor) && !v_is_null(cursor)) {
     setp(query, cursor_param, cursor);
   } else if (v_is_noval(getp(query, page_param))) {
-    voxgig_value* page = getp(paging, "page");
+    // A record written back by pre_result holds the page just fetched as
+    // "page" and the one to fetch as "nextPage", so nextPage wins.
+    voxgig_value* page = getp(paging, "nextPage");
+    if (v_is_noval(page) || v_is_null(page)) page = getp(paging, "page");
     if (!v_is_noval(page) && !v_is_null(page)) {
       setp(query, page_param, page);
     } else {
@@ -297,12 +301,16 @@ static void paging_pre_result(PagingFeature* pf, Context* ctx) {
     }
   }
 
-  // Body-level cursors.
+  // Body-level signals; snake_case forms are read first so camelCase wins.
   if (voxgig_is_map(body)) {
     voxgig_value* next = getp(body, "next");
     if (!v_is_noval(next) && !v_is_null(next) && v_is_noval(getp(paging, "next"))) {
       setp(paging, "next", next);
     }
+    voxgig_value* snake_cursor = getp(body, "next_cursor");
+    if (!v_is_noval(snake_cursor) && !v_is_null(snake_cursor)) {
+      setp(paging, "cursor", snake_cursor);
+    }
     voxgig_value* cursor = getp(body, "cursor");
     if (!v_is_noval(cursor) && !v_is_null(cursor)) {
       setp(paging, "cursor", cursor);
@@ -311,7 +319,18 @@ static void paging_pre_result(PagingFeature* pf, Context* ctx) {
     if (!v_is_noval(next_cursor) && !v_is_null(next_cursor)) {
       setp(paging, "cursor", next_cursor);
     }
+    if (v_is_noval(getp(paging, "nextPage"))) {
+      voxgig_value* np = getp(body, "nextPage");
+      if (v_is_noval(np) || v_is_null(np)) np = getp(body, "next_page");
+      if (voxgig_is_number(np) || voxgig_is_string(np)) {
+        setp(paging, "nextPage", np);
+      }
+    }
     bool has_more;
+    if (get_bool(body, "has_more", &has_more)) {
+      setp(paging, "hasMore", v_bool(has_more));
+      explicit_more = true;
+    }
     if (get_bool(body, "hasMore", &has_more)) {
       setp(paging, "hasMore", v_bool(has_more));
       explicit_more = true;
@@ -334,6 +353,21 @@ static void paging_pre_result(PagingFeature* pf, Context* ctx) {
 
   ctx->result->paging = paging;
   pf->last = paging;
+
+  if (ctx->ctrl) {
+    // The Context shares the caller's paging map by pointer, so refill it in
+    // place; a fresh map on ctrl never reaches the caller.
+    if (voxgig_is_map(ctx->ctrl->paging)) {
+      voxgig_map* dst = voxgig_as_map(ctx->ctrl->paging);
+      voxgig_map* src = voxgig_as_map(paging);
+      voxgig_map_clear(dst);
+      for (size_t i = 0; i < voxgig_map_len(src); i++) {
+        voxgig_map_set(dst, voxgig_map_key_at(src, i), v_share(voxgig_map_val_at(src, i)));
+      }
+    } else {
+      ctx->ctrl->paging = paging;
+    }
+  }
 }
 
 static void paging_hook(Feature* f, const char* name, Context* ctx) {

package/project/.sdk/tm/c/feature/test.c

@@ -30,20 +30,36 @@ static voxgig_value* envelope(Context* ctx, voxgig_value* data) {
   if (NULL == spec) {
     return data;
   }
-  // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-  // synthesise, so it is left alone rather than guessed at.
+  // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+  // GraphQL ops unwrap `body.data.<field>` (and `body.data.<field>.<entity>`
+  // for mutation payloads), not just a single envelope property.
   size_t n = strlen(spec);
   if (n < 8 || 0 != strncmp(spec, "`body.", 6) || '`' != spec[n - 1]) {
     return data;
   }
   size_t inner_len = n - 7;
-  if (0 == inner_len || NULL != memchr(spec + 6, '.', inner_len)) {
+  if (0 == inner_len) {
     return data;
   }
   char* inner = (char*)malloc(inner_len + 1);
   memcpy(inner, spec + 6, inner_len);
   inner[inner_len] = '\0';
-  voxgig_value* out = cmap(1, inner, data);
+  // Innermost segment first, so walk back from the end, terminating each
+  // segment in place as it is consumed. cmap copies the key.
+  voxgig_value* out = data;
+  size_t pos = inner_len;
+  while (1) {
+    size_t start = pos;
+    while (start > 0 && '.' != inner[start - 1]) {
+      start--;
+    }
+    inner[pos] = '\0';
+    out = cmap(1, inner + start, out);
+    if (0 == start) {
+      break;
+    }
+    pos = start - 1;
+  }
   free(inner);
   return out;
 }
@@ -76,23 +92,61 @@ static const char* test_entity_name(Context* ctx) {
   return ctx->op->entity;
 }
 
+static bool point_terminal(voxgig_value* p) {
+  voxgig_value* parts = getp(p, "parts");
+  if (!voxgig_is_list(parts)) return false;
+  voxgig_list* l = voxgig_as_list(parts);
+  if (0 == l->len) return false;
+  voxgig_value* last = l->items[l->len - 1];
+  return voxgig_is_string(last) && '{' == voxgig_as_string(last)[0];
+}
+
+static size_t point_depth(voxgig_value* p) {
+  voxgig_value* parts = getp(p, "parts");
+  return voxgig_is_list(parts) ? voxgig_as_list(parts)->len : 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).
+static voxgig_value* pick_point(voxgig_value* points) {
+  if (!voxgig_is_list(points)) return NULL;
+  voxgig_list* l = voxgig_as_list(points);
+  if (0 == l->len) return NULL;
+  voxgig_value* point = l->items[0];
+  for (size_t i = 1; i < l->len; i++) {
+    voxgig_value* cand = l->items[i];
+    if (point_terminal(cand) != point_terminal(point)) {
+      if (point_terminal(cand)) point = cand;
+    } else if (point_depth(cand) < point_depth(point)) {
+      point = cand;
+    }
+  }
+  return point;
+}
+
+static voxgig_value* reqd_names(voxgig_value* point, const char* kind) {
+  voxgig_value* args_path = getpath2(point, "args", kind);
+  voxgig_value* reqd_args = voxgig_select(args_path, cmap(1, "reqd", v_bool(true)));
+  voxgig_value* reqd_spec =
+      clist(3, v_str("`$EACH`"), v_str(""), v_str("`$KEY.name`"));
+  voxgig_value* reqd = voxgig_transform(reqd_args, reqd_spec, NULL);
+  if (!voxgig_is_list(reqd)) reqd = v_list();
+  return reqd;
+}
+
 static voxgig_value* build_args(Context* ctx, voxgig_value* args) {
   Operation* op = ctx->op;
   const char* opname = op->name;
   const char* entname = test_entity_name(ctx);
 
-  // Get last point from config.
   const char* ppath[6] = {"entity", entname, "op", opname, "points", NULL};
   voxgig_value* points = getpath_c(ctx->config, ppath);
-  voxgig_value* point = voxgig_getelem(points, v_int(-1), NULL);
+  voxgig_value* point = pick_point(points);
 
-  // Get required params.
-  voxgig_value* params_path = getpath2(point, "args", "params");
-  voxgig_value* reqd_params = voxgig_select(params_path, cmap(1, "reqd", v_bool(true)));
-  voxgig_value* reqd_spec =
-      clist(3, v_str("`$EACH`"), v_str(""), v_str("`$KEY.name`"));
-  voxgig_value* reqd = voxgig_transform(reqd_params, reqd_spec, NULL);
-  if (!voxgig_is_list(reqd)) reqd = v_list();
+  // 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.
+  voxgig_value* reqd_params = reqd_names(point, "params");
+  voxgig_value* reqd_query = reqd_names(point, "query");
 
   voxgig_value* qand = v_list();
   voxgig_value* q = cmap(1, "`$AND`", qand);
@@ -102,8 +156,8 @@ static voxgig_value* build_args(Context* ctx, voxgig_value* args) {
     for (size_t ki = 0; ki < keys.len; ki++) {
       const char* key = keys.data[ki];
       bool is_id = strcmp(key, "id") == 0;
-      voxgig_value* selected = voxgig_select(reqd, v_str(key));
-      bool is_reqd = !voxgig_isempty(selected);
+      bool is_reqd = !voxgig_isempty(voxgig_select(reqd_params, v_str(key))) ||
+                     !voxgig_isempty(voxgig_select(reqd_query, v_str(key)));
 
       if (is_id || is_reqd) {
         voxgig_value* v = param_util(ctx, v_str(key));
@@ -193,28 +247,14 @@ static voxgig_value* test_fetch(voxgig_value* entity, Context* ctx, const char*
     voxgig_value* args = build_args(ctx, update_match);
     voxgig_value* found = voxgig_select(entmap, args);
     voxgig_value* ent = voxgig_getelem(found, v_int(0), NULL);
-    if ((v_is_noval(ent) || v_is_null(ent)) && voxgig_size(entmap) > 0) {
-      // Fall back to any entity in the fixture.
-      voxgig_value* items = voxgig_items_v(entmap);
-      voxgig_list* il = voxgig_as_list(items);
-      for (size_t i = 0; i < il->len; i++) {
-        voxgig_value* e = voxgig_getelem(il->items[i], v_int(1), NULL);
-        if (voxgig_is_map(e)) {
-          ent = e;
-          break;
-        }
-      }
-    }
     if (v_is_noval(ent) || v_is_null(ent)) {
+      // update miss: 404, never another record
       voxgig_value* r = respond(ctx, 404, v_undef());
       setp(r, "statusText", v_str("Not found"));
       return r;
     }
     if (voxgig_is_map(ent) && voxgig_is_map(reqdata)) {
-      voxgig_map* rm = voxgig_as_map(reqdata);
-      for (size_t i = 0; i < rm->len; i++) {
-        setp(ent, rm->entries[i].key, rm->entries[i].value);
-      }
+      ent = voxgig_merge(clist(2, v_share(ent), v_share(reqdata)), VOXGIG_MAXDEPTH);
     }
     voxgig_delprop(ent, v_str("$KEY"));
     return respond(ctx, 200, voxgig_clone(ent));

package/project/.sdk/tm/c/utility/prepare_query.c

@@ -28,7 +28,8 @@ voxgig_value* prepare_query_util(Context* ctx) {
     for (size_t i = 0; i < rm->len; i++) {
       const char* key = rm->entries[i].key;
       voxgig_value* val = rm->entries[i].value;
-      if (!v_is_noval(val) && !v_is_null(val) && !params_contains(params, key)) {
+      if (!v_is_noval(val) && !v_is_null(val) && strcmp(key, "$action") != 0 &&
+          !params_contains(params, key)) {
         setp(out, key, v_share(val));
       }
     }

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

@@ -2,6 +2,28 @@
 
 #include "sdk.h"
 
+#include <string.h>
+
+/* `$action` selects the point (see make_point_util); it is never an API
+   field, so the body is a copy without it. The caller's map is left
+   untouched. */
+static voxgig_value* strip_action(voxgig_value* reqdata) {
+  if (!voxgig_is_map(reqdata)) return reqdata;
+  voxgig_map* rm = voxgig_as_map(reqdata);
+  bool has = false;
+  for (size_t i = 0; i < rm->len; i++) {
+    if (strcmp(rm->entries[i].key, "$action") == 0) { has = true; break; }
+  }
+  if (!has) return reqdata;
+  voxgig_value* body = voxgig_new_map();
+  for (size_t i = 0; i < rm->len; i++) {
+    if (strcmp(rm->entries[i].key, "$action") != 0) {
+      setp(body, rm->entries[i].key, v_share(rm->entries[i].value));
+    }
+  }
+  return body;
+}
+
 voxgig_value* transform_request_util(Context* ctx) {
   Spec* spec = ctx->spec;
   voxgig_value* point = ctx->point;
@@ -9,14 +31,14 @@ voxgig_value* transform_request_util(Context* ctx) {
   if (spec) spec_set_step(spec, "reqform");
 
   voxgig_value* transform = to_map(getp(point, "transform"));
-  if (v_is_noval(transform)) return ctx->reqdata;
+  if (v_is_noval(transform)) return strip_action(ctx->reqdata);
 
   voxgig_value* reqform = getp(transform, "req");
-  if (v_is_noval(reqform) || v_is_null(reqform)) return ctx->reqdata;
+  if (v_is_noval(reqform) || v_is_null(reqform)) return strip_action(ctx->reqdata);
 
   voxgig_value* store = cmap(1, "reqdata", v_share(ctx->reqdata));
   /* Return the transform result verbatim, as the ts reference does. Falling
      back to ctx->reqdata meant a reqform naming a path that does not resolve
      sent the WHOLE request data instead of nothing. */
-  return voxgig_transform(store, reqform, NULL);
+  return strip_action(voxgig_transform(store, reqform, NULL));
 }

package/project/.sdk/tm/clojure/src/sdk/core.clj

@@ -305,7 +305,9 @@
         cprop (fn [k] (mget ctxmap k))
         client (or (cprop "client") (bget :client))
         utility (or (cprop "utility") (bget :utility))
-        ;; ctrl: explicit ctrl map -> fresh control; else share base ctrl.
+        ;; ctrl: explicit ctrl map -> fresh control; an OPERATION (one named by
+        ;; opname) also gets its own, so a paging cursor cannot leak into the
+        ;; next call; anything else shares the base ctrl.
         ctrl-raw (cprop "ctrl")
         ctrl (cond
                (vs/ismap ctrl-raw)
@@ -315,7 +317,7 @@
                  (when (contains? (into #{} (vs/keysof ctrl-raw)) "actor") (oset! c :actor (mget ctrl-raw "actor")))
                  (when (vs/ismap (mget ctrl-raw "paging")) (oset! c :paging (mget ctrl-raw "paging")))
                  c)
-               (bget :ctrl) (bget :ctrl)
+               (and (nil? (cprop "opname")) (bget :ctrl)) (bget :ctrl)
                :else (make-control))
         meta (let [m (cprop "meta")] (if (vs/ismap m) m (or (bget :meta) (vs/jm))))
         config (let [c (cprop "config")] (if (vs/ismap c) c (bget :config)))
@@ -502,18 +504,30 @@
         out (vs/jm)]
     (doseq [item (or (vs/items reqmatch) [])]
       (let [k (vs/getprop item 0) v (vs/getprop item 1)]
-        (when (and (some? v) (string? k) (not (contains? pset k)))
+        (when (and (some? v) (string? k) (not= "$action" k) (not (contains? pset k)))
           (.put ^java.util.Map out k v))))
     out))
 
+;; `$action` selects the point (see u-make-point); it is never an API field,
+;; so the body is a copy without it. The caller's map is left untouched.
+(defn- strip-action [reqdata]
+  (if (and (vs/ismap reqdata) (.containsKey ^java.util.Map reqdata "$action"))
+    (let [body (vs/jm)]
+      (doseq [item (or (vs/items reqdata) [])]
+        (let [k (vs/getprop item 0) v (vs/getprop item 1)]
+          (when (not= "$action" k) (.put ^java.util.Map body k v))))
+      body)
+    reqdata))
+
 (defn u-transform-request [ctx]
   (let [spec (oget ctx :spec) point (oget ctx :point)]
     (when spec (oset! spec :step "reqform"))
     (let [transform (to-map (vs/getprop point "transform"))]
-      (if (nil? transform) (oget ctx :reqdata)
-          (let [reqform (vs/getprop transform "req")]
-            (if (nil? reqform) (oget ctx :reqdata)
-                (vs/transform (vs/jm "reqdata" (oget ctx :reqdata)) reqform)))))))
+      (strip-action
+       (if (nil? transform) (oget ctx :reqdata)
+           (let [reqform (vs/getprop transform "req")]
+             (if (nil? reqform) (oget ctx :reqdata)
+                 (vs/transform (vs/jm "reqdata" (oget ctx :reqdata)) reqform))))))))
 
 (defn u-prepare-body [ctx]
   (if (= "data" (op-input (oget ctx :op))) (ucall ctx :transform-request) nil))

package/project/.sdk/tm/clojure/src/sdk/features.clj

@@ -124,11 +124,13 @@
                        (let [envelope (fn [data]
                                         (let [tm (vs/getprop (core/oget fctx :point) "transform")
                                               spec (vs/getprop tm "res")]
-                                          ;; Exactly `body.<key>`; a deeper path is not an
-                                          ;; envelope this mock can synthesise.
+                                          ;; Rebuild whatever nesting the transform unwraps;
+                                          ;; GraphQL ops unwrap `body.data.<field>`.
                                           (if (and (some? data) (string? spec))
-                                            (if-let [m (re-matches #"`body\.([^`.]+)`" spec)]
-                                              (vs/jm (second m) data)
+                                            (if-let [m (re-matches #"`body\.(.+)`" spec)]
+                                              (reduce (fn [out seg] (vs/jm seg out))
+                                                      data
+                                                      (reverse (str/split (second m) #"\." -1)))
                                               data)
                                             data)))
                              respond (fn [status data extra]
@@ -175,14 +177,11 @@
                              (let [update-match (if (zero? (vs/size update-match)) (resolve-match (vs/jm)) update-match)
                                    args (test-build-args fctx op update-match)
                                    found (vs/select entmap args)
-                                   ent0 (vs/getelem found 0)
-                                   ent (if (and (nil? ent0) (vs/ismap entmap) (pos? (vs/size entmap)))
-                                         (first (filter vs/ismap (map #(vs/getprop entmap %) (vs/keysof entmap))))
-                                         ent0)]
+                                   ent (vs/getelem found 0)]
+                               ;; update miss: 404, never another record
                                (if (nil? ent) (respond 404 nil (vs/jm "statusText" "Not found"))
-                                   (do (when (and (vs/ismap ent) reqdata)
-                                         (doseq [item (or (vs/items reqdata) [])]
-                                           (.put ^java.util.Map ent (vs/getprop item 0) (vs/getprop item 1))))
+                                   (do (when (and (vs/ismap ent) (vs/ismap reqdata))
+                                         (vs/merge (vs/jt ent reqdata)))
                                        (vs/delprop ent "$KEY")
                                        (respond 200 (vs/clone ent) nil)))))
                            (= opn "remove")
@@ -208,20 +207,47 @@
                              (if (nil? net) test-fetcher (make-netsim fa net test-fetcher)))))))
     fa))
 
+(defn- point-terminal? [p]
+  (let [parts (vs/getprop p "parts")
+        n (if (vs/islist parts) (vs/size parts) 0)
+        last-part (when (pos? n) (vs/getelem parts (dec n)))]
+    (and (string? last-part) (str/starts-with? last-part "{"))))
+
+(defn- point-depth [p]
+  (let [parts (vs/getprop p "parts")]
+    (if (vs/islist parts) (vs/size 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).
+(defn- pick-point [points]
+  (when (and (vs/islist points) (pos? (vs/size points)))
+    (reduce (fn [point cand]
+              (cond
+                (not= (point-terminal? cand) (point-terminal? point)) (if (point-terminal? cand) cand point)
+                (< (point-depth cand) (point-depth point)) cand
+                :else point))
+            (vs/getelem points 0)
+            (map #(vs/getelem points %) (range 1 (vs/size points))))))
+
+(defn- reqd-names [point kind]
+  (vs/transform (vs/select (vs/getpath point (str "args." kind)) (vs/jm "reqd" true))
+                (vs/jt "`$EACH`" "" "`$KEY.name`")))
+
 (defn- test-build-args [ctx op args]
   (let [opname (core/op-name op)
         points (vs/getpath (core/oget ctx :config)
                            (str "entity." (core/entity-get-name (core/oget ctx :entity)) ".op." opname ".points"))
-        point (vs/getelem points -1)
-        params-path (vs/getpath point "args.params")
-        reqd-params (vs/select params-path (vs/jm "reqd" true))
-        reqd (vs/transform reqd-params (vs/jt "`$EACH`" "" "`$KEY.name`"))
+        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.
+        reqd-params (reqd-names point "params")
+        reqd-query (reqd-names point "query")
         qand (vs/jt)]
     (when args
       (doseq [key (or (vs/keysof args) [])]
         (let [is-id (= key "id")
-              selected (vs/select reqd key)
-              is-reqd (not (vs/isempty selected))]
+              is-reqd (or (not (vs/isempty (vs/select reqd-params key)))
+                          (not (vs/isempty (vs/select reqd-query key))))]
           (when (or is-id is-reqd)
             (let [v ((core/uget ctx :param) ctx key)
                   ka (when (core/op-alias op) (vs/getprop (core/op-alias op) key))
@@ -562,7 +588,14 @@
                          (cond
                            (some? (mget paging "cursor")) (.put ^java.util.Map q cursor-param (mget paging "cursor"))
                            (nil? (mget q page-param))
-                           (.put ^java.util.Map q page-param (if (nil? (mget paging "page")) (opt fa "startPage" 1) (mget 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.
+                           (.put ^java.util.Map q page-param
+                                 (cond
+                                   (some? (mget paging "nextPage")) (mget paging "nextPage")
+                                   (some? (mget paging "page")) (mget paging "page")
+                                   :else (opt fa "startPage" 1))))
                          (when (and (some? (opt fa "limit")) (nil? (mget q limit-param)))
                            (.put ^java.util.Map q limit-param (opt fa "limit"))))))))))
            "PreResult"
@@ -607,12 +640,21 @@
                                  (reset! explicit-more true))))))
                        (when (vs/ismap body)
                          (when (some? (mget body "next")) (when (nil? (mget paging "next")) (.put ^java.util.Map paging "next" (mget body "next"))))
+                         ;; Both spellings, camelCase last so it wins when a
+                         ;; body carries the two.
+                         (when (some? (mget body "next_cursor")) (.put ^java.util.Map paging "cursor" (mget body "next_cursor")))
                          (when (some? (mget body "cursor")) (.put ^java.util.Map paging "cursor" (mget body "cursor")))
                          (when (some? (mget body "nextCursor")) (.put ^java.util.Map paging "cursor" (mget body "nextCursor")))
-                         (let [hm (mget body "hasMore")]
-                           (when (or (= hm true) (= hm false))
-                             (.put ^java.util.Map paging "hasMore" hm)
-                             (reset! explicit-more true))))
+                         (when (nil? (mget paging "nextPage"))
+                           (let [np (if (some? (mget body "nextPage"))
+                                      (mget body "nextPage") (mget body "next_page"))]
+                             (when (or (number? np) (string? np))
+                               (.put ^java.util.Map paging "nextPage" np))))
+                         (doseq [k ["has_more" "hasMore"]]
+                           (let [hm (mget body k)]
+                             (when (or (= hm true) (= hm false))
+                               (.put ^java.util.Map paging "hasMore" hm)
+                               (reset! explicit-more true)))))
                        ;; Cursor presence only INFERS another page. When the
                        ;; server stated the answer outright — relay's
                        ;; `hasNextPage: false`, or a body `hasMore` — that
@@ -625,6 +667,16 @@
                                (boolean (or (mget paging "hasMore") (some? (mget paging "next"))
                                             (some? (mget paging "cursor")) (some? (mget paging "nextPage")))))))
                      (core/oset! result :paging paging)
+                     (when-let [ctrl (core/oget ctx :ctrl)]
+                       (let [held (core/oget ctrl :paging)]
+                         (if (vs/ismap held)
+                           ;; The caller holds this map, so refill it in place
+                           ;; as the other typed ports do; a fresh map on ctrl
+                           ;; would never reach them. Every key of the record
+                           ;; is written, so no key of an earlier page lives on.
+                           (doseq [k (vec (vs/keysof paging))]
+                             (.put ^java.util.Map held k (mget paging k)))
+                           (core/oset! ctrl :paging paging))))
                      (track-set! fa "_paging" (vs/jm "last" paging)))))))
            )
     fa))

package/project/.sdk/tm/cpp/core/types.hpp

@@ -690,7 +690,7 @@ inline Context::Context(const CtxSpec& cs, const CtxPtr& basectx) {
     if (a.is_string()) ctrl->actor = a.as_string();
     Value p = getp(cs.ctrlMap, "paging");
     if (p.is_map()) ctrl->paging = p;
-  } else if (basectx && basectx->ctrl) {
+  } else if (basectx && basectx->ctrl && cs.opname.empty()) {
     ctrl = basectx->ctrl;
   }
 

package/project/.sdk/tm/cpp/feature/paging.hpp

@@ -3,7 +3,8 @@
 // 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` body fields — onto ctx.result.paging.
+// `next`/`cursor`/`nextCursor`/`hasMore` body fields (snake_case forms too)
+// — onto ctx.result.paging and the caller's ctrl paging.
 // A per-call cursor/page from ctrl takes priority (auto-iteration).
 
 #ifndef SDK_FEATURE_PAGING_HPP
@@ -61,7 +62,10 @@ public:
     if (!is_nullish(cursor)) {
       map_put(spec->query, cursorParam, cursor);
     } else if (is_nullish(getp(spec->query, pageParam))) {
-      Value page = getp(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.
+      Value page = getp(paging, "nextPage");
+      if (is_nullish(page)) page = getp(paging, "page");
       if (!is_nullish(page)) {
         map_put(spec->query, pageParam, page);
       } else {
@@ -171,12 +175,16 @@ public:
       }
     }
 
-    // Body-level cursors.
+    // Body-level signals; snake_case forms are read first so camelCase wins.
     if (body.is_map()) {
       Value bnext = getp(body, "next");
       if (!is_nullish(bnext) && is_nullish(getp(paging, "next"))) {
         map_put(paging, "next", bnext);
       }
+      Value bsnakeCursor = getp(body, "next_cursor");
+      if (!is_nullish(bsnakeCursor)) {
+        map_put(paging, "cursor", bsnakeCursor);
+      }
       Value bcursor = getp(body, "cursor");
       if (!is_nullish(bcursor)) {
         map_put(paging, "cursor", bcursor);
@@ -185,6 +193,18 @@ public:
       if (!is_nullish(bnextCursor)) {
         map_put(paging, "cursor", bnextCursor);
       }
+      if (is_nullish(getp(paging, "nextPage"))) {
+        Value np = getp(body, "nextPage");
+        if (is_nullish(np)) np = getp(body, "next_page");
+        if (np.is_number() || np.is_string()) {
+          map_put(paging, "nextPage", np);
+        }
+      }
+      Value bsnakeMore = getp(body, "has_more");
+      if (bsnakeMore.is_bool()) {
+        map_put(paging, "hasMore", bsnakeMore);
+        explicitMore = true;
+      }
       Value bhasMore = getp(body, "hasMore");
       if (bhasMore.is_bool()) {
         map_put(paging, "hasMore", bhasMore);
@@ -205,6 +225,19 @@ public:
 
     result->paging = paging;
     last = paging;
+
+    if (ctx->ctrl) {
+      // Value maps are shared_ptr-backed, so the caller's map is refilled in
+      // place; a fresh map on ctrl never reaches the caller.
+      if (ctx->ctrl->paging.is_map()) {
+        ctx->ctrl->paging.as_map()->clear();
+        for (const auto& kv : *paging.as_map()) {
+          map_put(ctx->ctrl->paging, kv.first, kv.second);
+        }
+      } else {
+        ctx->ctrl->paging = paging;
+      }
+    }
   }
 
 private: