@voxgig/sdkgen 4.23.0 → 4.24.0

package/project/.sdk/tm/csharp/feature/PagingFeature.cs

@@ -2,8 +2,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 `ctx.Result.Paging`. A per-call cursor/page from ctrl takes
+// `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 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.
@@ -79,8 +79,12 @@ public class PagingFeature : BaseFeature
         }
         else if (!spec.Query.TryGetValue(pageParam, out var existing) || existing == null)
         {
+            // A record written back by PreResult holds the page just fetched
+            // as "page" and the one to fetch as "nextPage", so nextPage wins.
             object? page = null;
-            var hasPage = paging != null && paging.TryGetValue("page", out page) && page != null;
+            var hasPage = paging != null &&
+                ((paging.TryGetValue("nextPage", out page) && page != null) ||
+                 (paging.TryGetValue("page", out page) && page != null));
             spec.Query[pageParam] = hasPage ? page : FoptInt(_options, "startPage", 1);
         }
 
@@ -224,7 +228,7 @@ public class PagingFeature : BaseFeature
             }
         }
 
-        // Body-level cursors.
+        // Body-level signals; snake_case forms are read first so camelCase wins.
         if (body is Dictionary<string, object?> bm)
         {
             if (bm.TryGetValue("next", out var next) && next != null &&
@@ -232,6 +236,10 @@ public class PagingFeature : BaseFeature
             {
                 paging["next"] = next;
             }
+            if (bm.TryGetValue("next_cursor", out var snakeCursor) && snakeCursor != null)
+            {
+                paging["cursor"] = snakeCursor;
+            }
             if (bm.TryGetValue("cursor", out var cursor) && cursor != null)
             {
                 paging["cursor"] = cursor;
@@ -240,6 +248,34 @@ public class PagingFeature : BaseFeature
             {
                 paging["cursor"] = nextCursor;
             }
+            if (!paging.TryGetValue("nextPage", out var np0) || np0 == null)
+            {
+                bm.TryGetValue("nextPage", out var np);
+                if (np == null)
+                {
+                    bm.TryGetValue("next_page", out np);
+                }
+                switch (np)
+                {
+                    case int n:
+                        paging["nextPage"] = n;
+                        break;
+                    case long n:
+                        paging["nextPage"] = (int)n;
+                        break;
+                    case double n:
+                        paging["nextPage"] = (int)n;
+                        break;
+                    case string s:
+                        paging["nextPage"] = s;
+                        break;
+                }
+            }
+            if (bm.TryGetValue("has_more", out var snakeMore) && snakeMore is bool smb)
+            {
+                paging["hasMore"] = smb;
+                explicitMore = true;
+            }
             if (bm.TryGetValue("hasMore", out var hasMore) && hasMore is bool hmb)
             {
                 paging["hasMore"] = hmb;
@@ -262,6 +298,24 @@ public class PagingFeature : BaseFeature
 
         result.Paging = paging;
         Last = paging;
+
+        if (ctx.Ctrl != null)
+        {
+            // The Context shares the caller's paging map by reference, so
+            // refill it in place; a fresh map on Ctrl never reaches the caller.
+            if (ctx.Ctrl.Paging != null)
+            {
+                ctx.Ctrl.Paging.Clear();
+                foreach (var kv in paging)
+                {
+                    ctx.Ctrl.Paging[kv.Key] = kv.Value;
+                }
+            }
+            else
+            {
+                ctx.Ctrl.Paging = paging;
+            }
+        }
     }
 
     private bool IsList(Context ctx)

package/project/.sdk/tm/csharp/feature/TestFeature.cs

@@ -188,30 +188,17 @@ public class TestFeature : BaseFeature
                 var args = BuildArgs(ctx2, op, updateMatch);
                 var found = StructUtils.Select(entmap, args);
                 var ent = StructUtils.GetElem(found, 0);
-                if (ent == null && entmap != null)
-                {
-                    foreach (var e in entmap.Values)
-                    {
-                        if (e is Dictionary<string, object?>)
-                        {
-                            ent = e;
-                            break;
-                        }
-                    }
-                }
                 if (ent == null)
                 {
+                    // update miss: 404, never another record
                     return Respond(404, null, new Dictionary<string, object?>
                     {
                         ["statusText"] = "Not found",
                     });
                 }
-                if (ent is Dictionary<string, object?> entm && ctx2.Reqdata != null)
+                if (ent is Dictionary<string, object?> && ctx2.Reqdata != null)
                 {
-                    foreach (var kv in ctx2.Reqdata)
-                    {
-                        entm[kv.Key] = kv.Value;
-                    }
+                    StructUtils.Merge(new List<object?> { ent, ctx2.Reqdata });
                 }
                 StructUtils.DelProp(ent, "$KEY");
                 var outval = StructUtils.Clone(ent);
@@ -384,11 +371,16 @@ public class TestFeature : BaseFeature
             }
         }
 
-        // Get required params.
-        var paramsPath = StructUtils.GetPath(point, StructUtils.Jt("args", "params"));
-        var reqdParams = StructUtils.Select(paramsPath,
-            new Dictionary<string, object?> { ["reqd"] = true });
-        var reqd = StructUtils.Transform(reqdParams,
+        // 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.
+        var reqdArgs = new List<object?>();
+        foreach (var kind in new[] { "params", "query" })
+        {
+            var argsPath = StructUtils.GetPath(point, StructUtils.Jt("args", kind));
+            reqdArgs.AddRange(StructUtils.Select(argsPath,
+                new Dictionary<string, object?> { ["reqd"] = true }));
+        }
+        var reqd = StructUtils.Transform(reqdArgs,
             StructUtils.Jt("`$EACH`", "", "`$KEY.name`"));
 
         var qand = new List<object?>();

package/project/.sdk/tm/csharp/utility/Fetcher.cs

@@ -11,7 +11,19 @@ namespace ProjectNameSdk.Util;
 
 public static partial class SdkUtility
 {
-    private static readonly HttpClient DefaultHttpClient = new();
+    // Cookies OFF on every handler. The clients are process-wide, so a
+    // CookieContainer would send one call's Set-Cookie on the next, under a
+    // different credential — and .NET ADDS container cookies to a request
+    // that already carries a Cookie header, which an `apiKey in: cookie`
+    // scheme does. Pooling is the handler's own and is unaffected.
+    private static HttpClientHandler CookielessHandler(bool allowRedirect) =>
+        new HttpClientHandler
+        {
+            AllowAutoRedirect = allowRedirect,
+            UseCookies = false,
+        };
+
+    private static readonly HttpClient DefaultHttpClient = new(CookielessHandler(true));
 
     // Non-following twin of DefaultHttpClient. The station feature's
     // middleware sets `redirect: manual` on the fetch definition under a
@@ -20,11 +32,8 @@ public static partial class SdkUtility
     // to a Location no policy approved (the ts donor's fetch honours the
     // same key natively; redirect policy is per-handler in .NET, hence a
     // second client).
-    private static readonly HttpClient ManualRedirectHttpClient = new(
-        new HttpClientHandler
-        {
-            AllowAutoRedirect = false,
-        });
+    private static readonly HttpClient ManualRedirectHttpClient =
+        new(CookielessHandler(false));
 
     // Proxy-routed clients, cached per proxy URL and redirect policy (see
     // the proxy feature's fetchdef annotation).
@@ -43,12 +52,10 @@ public static partial class SdkUtility
                 var key = (manual ? "manual|" : "auto|") + proxy;
                 if (!ProxyClients.TryGetValue(key, out var client))
                 {
-                    client = new HttpClient(new HttpClientHandler
-                    {
-                        Proxy = new System.Net.WebProxy(proxy),
-                        UseProxy = true,
-                        AllowAutoRedirect = !manual,
-                    });
+                    var handler = CookielessHandler(!manual);
+                    handler.Proxy = new System.Net.WebProxy(proxy);
+                    handler.UseProxy = true;
+                    client = new HttpClient(handler);
                     ProxyClients[key] = client;
                 }
                 return client;

package/project/.sdk/tm/csharp/utility/PrepareQuery.cs

@@ -24,7 +24,7 @@ public static partial class SdkUtility
         {
             var key = item[0] as string ?? "";
             var val = item[1];
-            if (val != null && !ContainsStr(paramnames, key))
+            if (val != null && "$action" != key && !ContainsStr(paramnames, key))
             {
                 query[key] = val;
             }

package/project/.sdk/tm/csharp/utility/TransformRequest.cs

@@ -20,13 +20,13 @@ public static partial class SdkUtility
         var transform = Helpers.ToMapAny(StructUtils.GetProp(point, "transform"));
         if (transform == null)
         {
-            return ctx.Reqdata;
+            return StripAction(ctx.Reqdata);
         }
 
         var reqform = StructUtils.GetProp(transform, "req");
         if (reqform == null)
         {
-            return ctx.Reqdata;
+            return StripAction(ctx.Reqdata);
         }
 
         var reqdata = StructUtils.Transform(new Dictionary<string, object?>
@@ -34,6 +34,26 @@ public static partial class SdkUtility
             ["reqdata"] = ctx.Reqdata,
         }, reqform);
 
-        return reqdata;
+        return StripAction(reqdata);
+    }
+
+    // `$action` selects the point (see MakePointUtil); it is never an API
+    // field, so the body is a copy without it. The caller's map is left
+    // untouched.
+    private static object? StripAction(object? reqdata)
+    {
+        if (reqdata is not IDictionary<string, object?> src || !src.ContainsKey("$action"))
+        {
+            return reqdata;
+        }
+        var body = new Dictionary<string, object?>();
+        foreach (var kv in src)
+        {
+            if ("$action" != kv.Key)
+            {
+                body[kv.Key] = kv.Value;
+            }
+        }
+        return body;
     }
 }

package/project/.sdk/tm/elixir/lib/projectname/context.ex

@@ -57,7 +57,7 @@ defmodule ProjectName.Context do
         if S.ismap(pg), do: S.setprop(ctrl, "paging", pg)
         S.setprop(ctx, "ctrl", ctrl)
 
-      basectx != nil and bp.("ctrl") != nil ->
+      basectx != nil and bp.("ctrl") != nil and gp.("opname") == nil ->
         S.setprop(ctx, "ctrl", bp.("ctrl"))
 
       true ->

package/project/.sdk/tm/elixir/lib/projectname/feature/paging.ex

@@ -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 `ctx.result.paging`. A per-call cursor/page supplied via ctrl paging
+# `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case forms
+# too) — and records them on `ctx.result.paging` and the caller's ctrl paging. A per-call cursor/page supplied via ctrl paging
 # takes priority (used by auto-iteration). Parameter names
 # (`pageParam`/`limitParam`/`cursorParam`), `startPage` and page size
 # (`limit`) are configurable.
@@ -67,7 +67,10 @@ defmodule ProjectName.Feature.Paging do
               S.setprop(query, cursor_param, S.getprop(paging, "cursor"))
 
             S.getprop(query, page_param) == nil ->
-              page = S.getprop(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.
+              page = S.getprop(paging, "nextPage")
+              page = if page == nil, do: S.getprop(paging, "page"), else: page
               page = if page == nil, do: por(S.getprop(opts, "startPage"), 1), else: page
               S.setprop(query, page_param, page)
 
@@ -182,18 +185,16 @@ defmodule ProjectName.Feature.Paging do
                 bnext -> por(next_from_link, bnext)
               end
 
+            # snake_case forms rank below the camelCase ones.
             c =
               cond do
                 S.getprop(body, "nextCursor") != nil -> S.getprop(body, "nextCursor")
                 S.getprop(body, "cursor") != nil -> S.getprop(body, "cursor")
+                S.getprop(body, "next_cursor") != nil -> S.getprop(body, "next_cursor")
                 true -> nil
               end
 
-            hm =
-              case S.getprop(body, "hasMore") do
-                v when is_boolean(v) -> v
-                _ -> false
-              end
+            {hm, _} = body_more(body)
 
             {n, c, hm}
           else
@@ -239,10 +240,19 @@ defmodule ProjectName.Feature.Paging do
                 # No usable relay `more` path, but a top-level body hasMore is
                 # still an outright statement — keep it explicit, or cursor
                 # inference below would flip an explicit false to true.
-                {c, has_more, is_boolean(S.getprop(body, "hasMore"))}
+                {c, has_more, elem(body_more(body), 1)}
             end
           else
-            {cursor_val, has_more, is_boolean(S.getprop(body, "hasMore"))}
+            {cursor_val, has_more, elem(body_more(body), 1)}
+          end
+
+        next_page =
+          if next_page == nil and S.ismap(body) do
+            np = S.getprop(body, "nextPage")
+            np = if np == nil, do: S.getprop(body, "next_page"), else: np
+            if is_number(np) or is_binary(np), do: np, else: nil
+          else
+            next_page
           end
 
         # Cursor presence only INFERS another page. When the server stated the
@@ -268,6 +278,7 @@ defmodule ProjectName.Feature.Paging do
           ])
 
         S.setprop(result, "paging", paging)
+        write_back(S.getprop(ctx, "ctrl"), paging)
         S.setprop(S.getprop(f, "client"), "_paging", S.jm(["last", paging]))
       end
     end
@@ -275,6 +286,37 @@ defmodule ProjectName.Feature.Paging do
     nil
   end
 
+  # The Context shares the caller's paging map by reference, so refill it in
+  # place; a fresh map on ctrl never reaches the caller.
+  defp write_back(ctrl, paging) do
+    shared = if ctrl == nil, do: nil, else: S.getprop(ctrl, "paging")
+
+    cond do
+      ctrl == nil ->
+        nil
+
+      S.ismap(shared) ->
+        Enum.each(S.keysof(shared), fn k -> S.delprop(shared, k) end)
+        Enum.each(S.keysof(paging), fn k -> S.setprop(shared, k, S.getprop(paging, k)) end)
+
+      true ->
+        S.setprop(ctrl, "paging", paging)
+    end
+
+    nil
+  end
+
+  # Body `hasMore`, or `has_more` when the camelCase form is absent: {value,
+  # stated outright}.
+  defp body_more(body) do
+    cond do
+      not S.ismap(body) -> {false, false}
+      is_boolean(S.getprop(body, "hasMore")) -> {S.getprop(body, "hasMore"), true}
+      is_boolean(S.getprop(body, "has_more")) -> {S.getprop(body, "has_more"), true}
+      true -> {false, false}
+    end
+  end
+
   defp is_list_op(f, ctx) do
     ops = opt_list(S.getprop(F.opts(f), "ops"), ["list"])
     op = S.getprop(ctx, "op")

package/project/.sdk/tm/elixir/lib/projectname/feature/test.ex

@@ -167,20 +167,11 @@ defmodule ProjectName.Feature.Test do
         found = S.select(entmap, args)
         ent = S.getelem(found, 0)
 
-        ent =
-          if ent == nil and S.ismap(entmap) do
-            ks = S.keysof(entmap)
-            Enum.find_value(ks, fn k -> v = S.getprop(entmap, k); if S.ismap(v), do: v end)
-          else
-            ent
-          end
-
         if ent == nil do
+          # update miss: 404, never another record
           respond(fctx, 404, nil, S.jm(["statusText", "Not found"]))
         else
-          if S.ismap(ent) and reqdata != nil do
-            Enum.each(H.entries(reqdata), fn {k, v} -> S.setprop(ent, k, v) end)
-          end
+          if S.ismap(ent) and S.ismap(reqdata), do: S.merge(S.jt([ent, reqdata]))
 
           S.delprop(ent, "$KEY")
           respond(fctx, 200, S.clone(ent))
@@ -222,6 +213,45 @@ defmodule ProjectName.Feature.Test do
     :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
   end
 
+  defp point_terminal?(p) do
+    parts = S.getprop(p, "parts")
+    n = if S.islist(parts), do: S.size(parts), else: 0
+    last = if n > 0, do: S.getelem(parts, n - 1), else: nil
+    is_binary(last) and String.starts_with?(last, "{")
+  end
+
+  defp point_depth(p) do
+    parts = S.getprop(p, "parts")
+    if S.islist(parts), do: S.size(parts), else: 0
+  end
+
+  # 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).
+  defp pick_point(points) do
+    n = if S.islist(points), do: S.size(points), else: 0
+
+    if n == 0 do
+      nil
+    else
+      rest = if n > 1, do: Enum.to_list(1..(n - 1)), else: []
+
+      Enum.reduce(rest, S.getelem(points, 0), fn i, point ->
+        cand = S.getelem(points, i)
+
+        cond do
+          point_terminal?(cand) != point_terminal?(point) -> if point_terminal?(cand), do: cand, else: point
+          point_depth(cand) < point_depth(point) -> cand
+          true -> point
+        end
+      end)
+    end
+  end
+
+  defp reqd_names(point, kind) do
+    reqd_args = S.select(S.getpath(point, "args." <> kind), S.jm(["reqd", true]))
+    S.transform(reqd_args, S.jt(["`$EACH`", "", "`$KEY.name`"]))
+  end
+
   # Build a struct select query ($AND of $OR alternatives) from the required
   # params + id, resolving each value through the pipeline param resolver.
   def build_args(_f, ctx, op, args) do
@@ -229,10 +259,11 @@ defmodule ProjectName.Feature.Test do
     config = S.getprop(ctx, "config")
     entname = Context.entity_name(S.getprop(ctx, "entity"))
     points = S.getpath(config, "entity." <> entname <> ".op." <> opname <> ".points")
-    point = S.getelem(points, -1)
-    params_path = S.getpath(point, "args.params")
-    reqd_params = S.select(params_path, S.jm(["reqd", true]))
-    reqd = S.transform(reqd_params, S.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 = S.jt([])
     q = S.jm(["`$AND`", qand])
@@ -240,8 +271,7 @@ defmodule ProjectName.Feature.Test do
     if args != nil do
       Enum.each(S.keysof(args), fn key ->
         is_id = key == "id"
-        selected = S.select(reqd, key)
-        is_reqd = not S.isempty(selected)
+        is_reqd = not S.isempty(S.select(reqd_params, key)) or not S.isempty(S.select(reqd_query, key))
 
         if is_id or is_reqd do
           v = Utility.param(ctx, key)

package/project/.sdk/tm/elixir/lib/projectname/utility.ex

@@ -1209,7 +1209,8 @@ defmodule ProjectName.Utility do
     out = S.jm([])
 
     Enum.each(H.entries(reqmatch), fn {key, val} ->
-      if val != nil and is_binary(key) and not Enum.member?(param_strs, key) do
+      if val != nil and is_binary(key) and key != "$action" and
+           not Enum.member?(param_strs, key) do
         S.setprop(out, key, val)
       end
     end)
@@ -1446,6 +1447,23 @@ defmodule ProjectName.Utility do
 
   # ---- transform_* ---------------------------------------------------------
 
+  # `$action` selects the point (see make_point_impl); it is never an API
+  # field, so the body is a copy without it. The caller's map is left
+  # untouched.
+  defp strip_action(reqdata) do
+    if S.ismap(reqdata) and S.haskey(reqdata, "$action") do
+      body = S.jm([])
+
+      Enum.each(H.entries(reqdata), fn {key, val} ->
+        if key != "$action", do: S.setprop(body, key, val)
+      end)
+
+      body
+    else
+      reqdata
+    end
+  end
+
   def transform_request_impl(ctx) do
     spec = S.getprop(ctx, "spec")
     point = S.getprop(ctx, "point")
@@ -1453,17 +1471,20 @@ defmodule ProjectName.Utility do
 
     transform = H.to_map(S.getprop(point, "transform"))
 
-    if transform == nil do
-      S.getprop(ctx, "reqdata")
-    else
-      reqform = S.getprop(transform, "req")
-
-      if reqform == nil do
+    reqdata =
+      if transform == nil do
         S.getprop(ctx, "reqdata")
       else
-        S.transform(S.jm(["reqdata", S.getprop(ctx, "reqdata")]), reqform)
+        reqform = S.getprop(transform, "req")
+
+        if reqform == nil do
+          S.getprop(ctx, "reqdata")
+        else
+          S.transform(S.jm(["reqdata", S.getprop(ctx, "reqdata")]), reqform)
+        end
       end
-    end
+
+    strip_action(reqdata)
   end
 
   def transform_response_impl(ctx) do

package/project/.sdk/tm/go/core/context.go

@@ -9,18 +9,18 @@ import (
 )
 
 type Context struct {
-	Id      string
-	Out     map[string]any
-	Ctrl    *Control
-	Meta    map[string]any
-	Client  *ProjectNameSDK
-	Utility *Utility
-	Op      *Operation
-	Point   map[string]any
-	Config  map[string]any
-	Entopts map[string]any
-	Options map[string]any
-	Opmap   map[string]*Operation
+	Id       string
+	Out      map[string]any
+	Ctrl     *Control
+	Meta     map[string]any
+	Client   *ProjectNameSDK
+	Utility  *Utility
+	Op       *Operation
+	Point    map[string]any
+	Config   map[string]any
+	Entopts  map[string]any
+	Options  map[string]any
+	Opmap    map[string]*Operation
 	Opmu     *sync.Mutex
 	Response *Response
 	Result   *Result
@@ -86,7 +86,7 @@ func NewContext(ctxmap map[string]any, basectx *Context) *Context {
 		} else if ctrl, ok := c.(*Control); ok {
 			ctx.Ctrl = ctrl
 		}
-	} else if basectx != nil && basectx.Ctrl != nil {
+	} else if basectx != nil && basectx.Ctrl != nil && getCtxProp(ctxmap, "opname") == nil {
 		ctx.Ctrl = basectx.Ctrl
 	}
 

package/project/.sdk/tm/go/feature/paging_feature.go

@@ -68,7 +68,11 @@ func (f *PagingFeature) PreRequest(ctx *core.Context) {
 	if cursor, has := paging["cursor"]; has && cursor != nil {
 		spec.Query[cursorParam] = cursor
 	} else if spec.Query[pageParam] == nil {
-		if page, has := paging["page"]; has && page != nil {
+		// A record written back by PreResult holds the page just fetched as
+		// "page" and the one to fetch as "nextPage", so nextPage wins.
+		if next, has := paging["nextPage"]; has && next != nil {
+			spec.Query[pageParam] = next
+		} else if page, has := paging["page"]; has && page != nil {
 			spec.Query[pageParam] = page
 		} else {
 			spec.Query[pageParam] = foptInt(f.options, "startPage", 1)
@@ -178,17 +182,36 @@ func (f *PagingFeature) PreResult(ctx *core.Context) {
 		}
 	}
 
-	// Body-level cursors.
+	// Body-level signals; snake_case forms are read first so camelCase wins.
 	if bm, ok := body.(map[string]any); ok {
 		if bm["next"] != nil && paging["next"] == nil {
 			paging["next"] = bm["next"]
 		}
+		if bm["next_cursor"] != nil {
+			paging["cursor"] = bm["next_cursor"]
+		}
 		if bm["cursor"] != nil {
 			paging["cursor"] = bm["cursor"]
 		}
 		if bm["nextCursor"] != nil {
 			paging["cursor"] = bm["nextCursor"]
 		}
+		if paging["nextPage"] == nil {
+			np := bm["nextPage"]
+			if np == nil {
+				np = bm["next_page"]
+			}
+			switch n := np.(type) {
+			case float64:
+				paging["nextPage"] = int(n)
+			case int, string:
+				paging["nextPage"] = n
+			}
+		}
+		if hasMore, ok := bm["has_more"].(bool); ok {
+			paging["hasMore"] = hasMore
+			explicitMore = true
+		}
 		if hasMore, ok := bm["hasMore"].(bool); ok {
 			paging["hasMore"] = hasMore
 			explicitMore = true
@@ -207,6 +230,21 @@ func (f *PagingFeature) PreResult(ctx *core.Context) {
 
 	result.Paging = paging
 	f.Last = paging
+
+	if ctx.Ctrl != nil {
+		// The Context shares the caller's paging map by reference, so refill
+		// it in place; a fresh map on Ctrl would never reach the caller.
+		if ctx.Ctrl.Paging != nil {
+			for k := range ctx.Ctrl.Paging {
+				delete(ctx.Ctrl.Paging, k)
+			}
+			for k, v := range paging {
+				ctx.Ctrl.Paging[k] = v
+			}
+		} else {
+			ctx.Ctrl.Paging = paging
+		}
+	}
 }
 
 func (f *PagingFeature) isList(ctx *core.Context) bool {