@voxgig/sdkgen 4.23.0 → 4.24.0

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

@@ -164,24 +164,12 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 			args := self.buildArgs(ctx, op, updateMatch)
 			found := vs.Select(entmap, args)
 			ent := vs.GetElem(found, 0)
-			if ent == nil && entmap != nil {
-				for _, e := range entmap {
-					if _, ok := e.(map[string]any); ok {
-						ent = e
-						break
-					}
-				}
-			}
 			if ent == nil {
+				// update miss: 404, never another record
 				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
 			}
-			if entm, ok := ent.(map[string]any); ok {
-				reqdata := ctx.Reqdata
-				if reqdata != nil {
-					for k, v := range reqdata {
-						entm[k] = v
-					}
-				}
+			if _, ok := ent.(map[string]any); ok && ctx.Reqdata != nil {
+				vs.Merge([]any{ent, ctx.Reqdata})
 			}
 			vs.DelProp(ent, "$KEY")
 			out := vs.Clone(ent)

package/project/.sdk/tm/go/test/feature_corpus_test.go

@@ -428,6 +428,7 @@ func TestFeatureCorpus(t *testing.T) {
 				"feature": []any{map[string]any{"name": name, "active": true}},
 			})
 			if fcRecord(probe, name) == nil {
+				t.Logf("feature.%s: inert (this SDK does not generate the feature)", name)
 				t.Skipf("this SDK was generated without the %s feature", name)
 			}
 

package/project/.sdk/tm/go/test/feature_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"reflect"
 	"regexp"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -1042,6 +1043,59 @@ func TestFeaturePaging(t *testing.T) {
 		}
 	})
 
+	t.Run("snake-case-signals-and-ctrl-write-back", func(t *testing.T) {
+		rec := &fhRecorder{reply: func(n int, _ map[string]any) (any, error) {
+			if n == 1 {
+				return fhResponse(200, map[string]any{"has_more": true, "next_cursor": "c2"}, nil), nil
+			}
+			return fhResponse(200, map[string]any{"has_more": false}, nil), nil
+		}}
+		h := fhMake(rec.fetch, fhF(feat.NewPagingFeature(), nil))
+		pg := map[string]any{}
+		ctrl := map[string]any{"paging": pg}
+		res := h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if res.result.Paging["hasMore"] != true {
+			t.Errorf("expected has_more read, got %v", res.result.Paging["hasMore"])
+		}
+		if res.result.Paging["cursor"] != "c2" {
+			t.Errorf("expected next_cursor read, got %v", res.result.Paging["cursor"])
+		}
+		if pg["cursor"] != "c2" || pg["hasMore"] != true {
+			t.Errorf("expected record written back into ctrl, got %v", pg)
+		}
+		h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if !strings.Contains(rec.url(1), "cursor=c2") {
+			t.Errorf("expected written-back cursor sent, got %s", rec.url(1))
+		}
+		if pg["hasMore"] != false || pg["cursor"] != nil {
+			t.Errorf("expected ctrl to carry the last record, got %v", pg)
+		}
+	})
+
+	t.Run("continues-from-written-back-next-page", func(t *testing.T) {
+		rec := &fhRecorder{reply: func(n int, _ map[string]any) (any, error) {
+			body := map[string]any{}
+			if n == 1 {
+				body["next_page"] = 2
+			}
+			return fhResponse(200, body, map[string]any{"x-page": strconv.Itoa(n)}), nil
+		}}
+		h := fhMake(rec.fetch, fhF(feat.NewPagingFeature(), nil))
+		pg := map[string]any{}
+		ctrl := map[string]any{"paging": pg}
+		h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if pg["page"] != 1 || pg["nextPage"] != 2 || pg["hasMore"] != true {
+			t.Errorf("expected next_page read and written back, got %v", pg)
+		}
+		h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if !strings.Contains(rec.url(1), "page=2") {
+			t.Errorf("expected written-back next page sent, got %s", rec.url(1))
+		}
+		if pg["hasMore"] != false {
+			t.Errorf("expected no more pages, got %v", pg)
+		}
+	})
+
 	t.Run("non-list-not-paged", func(t *testing.T) {
 		rec := &fhRecorder{}
 		h := fhMake(rec.fetch, fhF(feat.NewPagingFeature(), nil))

package/project/.sdk/tm/go/utility/fetcher.go

@@ -6,12 +6,52 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
+	"sync"
 
 	vs "github.com/voxgig/struct"
 
 	"GOMODULE/core"
 )
 
+// Proxied clients keyed by proxy URL. A client per request would open a
+// fresh connection every call; a cached one pools like http.DefaultClient.
+var proxyClients sync.Map
+
+func clientFor(fetchdef map[string]any) *http.Client {
+	client := http.DefaultClient
+
+	if proxy, ok := fetchdef["proxy"].(string); ok && proxy != "" {
+		if cached, ok := proxyClients.Load(proxy); ok {
+			client = cached.(*http.Client)
+		} else if proxyURL, perr := url.Parse(proxy); perr == nil {
+			// http.DefaultTransport is a package variable the host program can
+			// replace, and an unchecked assertion on it panics the SDK inside
+			// whatever called it. Clone the real one where it is there, and
+			// build a plain transport where it is not.
+			var transport *http.Transport
+			if def, ok := http.DefaultTransport.(*http.Transport); ok {
+				transport = def.Clone()
+			} else {
+				transport = &http.Transport{}
+			}
+			transport.Proxy = http.ProxyURL(proxyURL)
+			cached, _ := proxyClients.LoadOrStore(proxy, &http.Client{Transport: transport})
+			client = cached.(*http.Client)
+		}
+	}
+
+	// A shallow copy shares the pooled Transport; only CheckRedirect differs.
+	if redirect, ok := fetchdef["redirect"].(string); ok && redirect == "manual" {
+		manual := *client
+		manual.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		}
+		client = &manual
+	}
+
+	return client
+}
+
 func defaultHTTPFetch(fullurl string, fetchdef map[string]any) (map[string]any, error) {
 	method, _ := fetchdef["method"].(string)
 	if method == "" {
@@ -46,26 +86,7 @@ func defaultHTTPFetch(fullurl string, fetchdef map[string]any) (map[string]any,
 		req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)")
 	}
 
-	// Honour a proxy annotation on the fetch definition (set by the proxy
-	// feature): route the request through an http.Transport with Proxy set.
-	client := http.DefaultClient
-	if proxy, ok := fetchdef["proxy"].(string); ok && proxy != "" {
-		if proxyURL, perr := url.Parse(proxy); perr == nil {
-			client = &http.Client{
-				Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
-			}
-		}
-	}
-
-	if redirect, ok := fetchdef["redirect"].(string); ok && redirect == "manual" {
-		manual := *client
-		manual.CheckRedirect = func(req *http.Request, via []*http.Request) error {
-			return http.ErrUseLastResponse
-		}
-		client = &manual
-	}
-
-	resp, err := client.Do(req)
+	resp, err := clientFor(fetchdef).Do(req)
 	if err != nil {
 		return nil, err
 	}

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

@@ -29,7 +29,7 @@ func prepareQueryUtil(ctx *core.Context) map[string]any {
 	for _, item := range vs.Items(reqmatch) {
 		key, _ := item[0].(string)
 		val := item[1]
-		if val != nil && !containsStr(params, key) {
+		if val != nil && key != "$action" && !containsStr(params, key) {
 			out[key] = val
 		}
 	}

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

@@ -16,12 +16,12 @@ func transformRequestUtil(ctx *core.Context) any {
 
 	transform := core.ToMapAny(vs.GetProp(point, "transform"))
 	if transform == nil {
-		return ctx.Reqdata
+		return stripAction(ctx.Reqdata)
 	}
 
 	reqform := vs.GetProp(transform, "req")
 	if reqform == nil {
-		return ctx.Reqdata
+		return stripAction(ctx.Reqdata)
 	}
 
 	reqdata, terr := vs.Transform(map[string]any{
@@ -36,5 +36,24 @@ func transformRequestUtil(ctx *core.Context) any {
 		return terr
 	}
 
-	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.
+func stripAction(reqdata any) any {
+	src, ok := reqdata.(map[string]any)
+	if !ok {
+		return reqdata
+	}
+	if _, has := src["$action"]; !has {
+		return reqdata
+	}
+	body := make(map[string]any, len(src))
+	for k, v := range src {
+		if k != "$action" {
+			body[k] = v
+		}
+	}
+	return body
 }

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

@@ -82,7 +82,8 @@ public class Context {
         this.ctrl = (Control) cv;
       }
     }
-    else if (basectx != null && basectx.ctrl != null) {
+    else if (basectx != null && basectx.ctrl != null
+        && Helpers.getCtxProp(ctxmap, "opname") == null) {
       this.ctrl = basectx.ctrl;
     }
 

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

@@ -18,8 +18,8 @@ import JAVAPACKAGE.utility.struct.Struct;
 // 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.
@@ -82,7 +82,12 @@ public class PagingFeature extends BaseFeature {
       spec.query.put(cursorParam, cursor);
     }
     else if (spec.query.get(pageParam) == null) {
-      Object page = paging.get("page");
+      // 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 = paging.get("nextPage");
+      if (page == null) {
+        page = paging.get("page");
+      }
       if (page != null) {
         spec.query.put(pageParam, page);
       }
@@ -206,18 +211,37 @@ public class PagingFeature extends BaseFeature {
       }
     }
 
-    // Body-level cursors.
+    // Body-level signals; snake_case forms are read first so camelCase wins.
     if (body instanceof Map) {
       Map<String, Object> bm = (Map<String, Object>) body;
       if (bm.get("next") != null && paging.get("next") == null) {
         paging.put("next", bm.get("next"));
       }
+      if (bm.get("next_cursor") != null) {
+        paging.put("cursor", bm.get("next_cursor"));
+      }
       if (bm.get("cursor") != null) {
         paging.put("cursor", bm.get("cursor"));
       }
       if (bm.get("nextCursor") != null) {
         paging.put("cursor", bm.get("nextCursor"));
       }
+      if (paging.get("nextPage") == null) {
+        Object np = bm.get("nextPage");
+        if (np == null) {
+          np = bm.get("next_page");
+        }
+        if (np instanceof Number) {
+          paging.put("nextPage", ((Number) np).intValue());
+        }
+        else if (np instanceof String) {
+          paging.put("nextPage", np);
+        }
+      }
+      if (bm.get("has_more") instanceof Boolean) {
+        paging.put("hasMore", bm.get("has_more"));
+        explicitMore = true;
+      }
       if (bm.get("hasMore") instanceof Boolean) {
         paging.put("hasMore", bm.get("hasMore"));
         explicitMore = true;
@@ -237,6 +261,24 @@ public class PagingFeature extends BaseFeature {
 
     result.paging = paging;
     this.last = paging;
+
+    if (ctx.ctrl != null) {
+      // The Context shares the caller's paging map by reference, so refill
+      // it in place; an immutable map falls back to replacing the reference.
+      Map<String, Object> shared = ctx.ctrl.paging;
+      if (shared == null) {
+        ctx.ctrl.paging = paging;
+      }
+      else {
+        try {
+          shared.clear();
+          shared.putAll(paging);
+        }
+        catch (UnsupportedOperationException e) {
+          ctx.ctrl.paging = paging;
+        }
+      }
+    }
   }
 
   private boolean isList(Context ctx) {

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

@@ -228,19 +228,12 @@ public class TestFeature extends BaseFeature {
       Object args = buildArgs(ctx, op, updateMatch);
       List<Object> found = Struct.select(entmap, args);
       Object ent = Struct.getelem(found, 0);
-      if (ent == null && entmap != null) {
-        for (Object e : entmap.values()) {
-          if (e instanceof Map) {
-            ent = e;
-            break;
-          }
-        }
-      }
       if (ent == null) {
+        // update miss: 404, never another record
         return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       if (ent instanceof Map && ctx.reqdata != null) {
-        ((Map<String, Object>) ent).putAll(ctx.reqdata);
+        Struct.merge(Struct.jt(ent, ctx.reqdata));
       }
       Struct.delprop(ent, "$KEY");
       Object out = Struct.clone(ent);
@@ -374,10 +367,14 @@ public class TestFeature extends BaseFeature {
       }
     }
 
-    // Get required params.
-    Object paramsPath = Struct.getpath(point, List.of("args", "params"));
-    Object reqdParams = Struct.select(paramsPath, Struct.jm("reqd", true));
-    Object reqd = Struct.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.
+    List<Object> reqdArgs = Struct.jt();
+    for (String kind : new String[] { "params", "query" }) {
+      Object argsPath = Struct.getpath(point, List.of("args", kind));
+      reqdArgs.addAll(Struct.select(argsPath, Struct.jm("reqd", true)));
+    }
+    Object reqd = Struct.transform(reqdArgs,
         Struct.jt("`$EACH`", "", "`$KEY.name`"));
 
     List<Object> qand = Struct.jt();

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

@@ -405,6 +405,9 @@ public class FeatureCorpusTest {
       ProjectNameSDK probe = buildClient(Map.of("feature",
           List.of(Map.of("name", name, "active", true))));
       if (null == record(probe, name)) {
+        // The one line every runner prints for an inert section.
+        System.err.println(String.format(
+            "feature.%s: inert (this SDK does not generate the feature)", name));
         continue;
       }
 

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

@@ -867,6 +867,48 @@ public class FeatureTest {
     assertEquals(true, res.result.paging.get("hasMore"), "expected hasMore");
   }
 
+  @Test
+  public void paging_snakeCaseSignalsAndCtrlWriteBack() {
+    assumeFeatures("paging");
+    FhRecorder rec = new FhRecorder();
+    rec.reply = (n, fetchdef) -> 1 == n
+        ? fhResponse(200, fhMap("has_more", true, "next_cursor", "c2"), null)
+        : fhResponse(200, fhMap("has_more", false), null);
+    FhHarness h = fhMake(rec::fetch, fhF(new PagingFeature(), null));
+    Map<String, Object> pg = new LinkedHashMap<>();
+    Map<String, Object> ctrl = fhMap("paging", pg);
+    FhOpResult res = h.op(fhOp("list").path("/w").ctrl(ctrl));
+    assertEquals(true, res.result.paging.get("hasMore"), "expected has_more read");
+    assertEquals("c2", res.result.paging.get("cursor"), "expected next_cursor read");
+    assertEquals("c2", pg.get("cursor"), "expected record written back into ctrl");
+    assertEquals(true, pg.get("hasMore"), "expected record written back into ctrl");
+    h.op(fhOp("list").path("/w").ctrl(ctrl));
+    assertTrue(rec.url(1).contains("cursor=c2"),
+        "expected written-back cursor sent: " + rec.url(1));
+    assertEquals(false, pg.get("hasMore"), "expected ctrl to carry the last record");
+    assertNull(pg.get("cursor"), "expected ctrl to carry the last record");
+  }
+
+  @Test
+  public void paging_continuesFromWrittenBackNextPage() {
+    assumeFeatures("paging");
+    FhRecorder rec = new FhRecorder();
+    rec.reply = (n, fetchdef) -> fhResponse(200,
+        1 == n ? fhMap("next_page", 2) : fhMap(),
+        fhMap("x-page", String.valueOf(n)));
+    FhHarness h = fhMake(rec::fetch, fhF(new PagingFeature(), null));
+    Map<String, Object> pg = new LinkedHashMap<>();
+    Map<String, Object> ctrl = fhMap("paging", pg);
+    h.op(fhOp("list").path("/w").ctrl(ctrl));
+    assertEquals(1, pg.get("page"), "expected x-page written back");
+    assertEquals(2, pg.get("nextPage"), "expected next_page written back");
+    assertEquals(true, pg.get("hasMore"), "expected hasMore inferred from next_page");
+    h.op(fhOp("list").path("/w").ctrl(ctrl));
+    assertTrue(rec.url(1).contains("page=2"),
+        "expected written-back next page sent: " + rec.url(1));
+    assertEquals(false, pg.get("hasMore"), "expected no more pages");
+  }
+
   @Test
   public void paging_nonListNotPaged() {
     assumeFeatures("paging");

package/project/.sdk/tm/java/utility/Fetcher.java

@@ -9,6 +9,7 @@ import java.net.http.HttpResponse;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
 import java.util.function.Supplier;
 
@@ -20,6 +21,40 @@ final class Fetcher {
 
   private Fetcher() {}
 
+  // Clients keyed by redirect policy and proxy. Each HttpClient owns a
+  // connection pool and a selector thread, so one per request reused
+  // nothing; one per key pools across calls.
+  private static final ConcurrentHashMap<String, HttpClient> CLIENTS =
+      new ConcurrentHashMap<>();
+
+  private static HttpClient clientFor(Map<String, Object> fetchdef) {
+    // "manual" (set by the station feature's middleware under a hosts
+    // policy) returns a 3xx like any other response: an automatic follow
+    // would carry injected credentials to a host no policy approved.
+    final HttpClient.Redirect redirectPolicy =
+        "manual".equals(fetchdef.get("redirect"))
+            ? HttpClient.Redirect.NEVER
+            : HttpClient.Redirect.NORMAL;
+
+    Object praw = fetchdef.get("proxy");
+    final String proxy = praw instanceof String ? (String) praw : "";
+
+    return CLIENTS.computeIfAbsent(redirectPolicy + "|" + proxy, key -> {
+      HttpClient.Builder clientb = HttpClient.newBuilder().followRedirects(redirectPolicy);
+      if (!"".equals(proxy)) {
+        try {
+          URI proxyUri = URI.create(proxy);
+          int port = proxyUri.getPort() < 0 ? 80 : proxyUri.getPort();
+          clientb.proxy(ProxySelector.of(new InetSocketAddress(proxyUri.getHost(), port)));
+        }
+        catch (RuntimeException e) {
+          // Unparseable proxy target: direct connection, as the go transport.
+        }
+      }
+      return clientb.build();
+    });
+  }
+
   static Map<String, Object> defaultHttpFetch(String fullurl, Map<String, Object> fetchdef) {
     String method = fetchdef.get("method") instanceof String
         ? (String) fetchdef.get("method") : "";
@@ -59,36 +94,9 @@ final class Fetcher {
       reqb.setHeader("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)");
     }
 
-    // Honour a redirect annotation on the fetch definition (set by the
-    // station feature's middleware under a hosts policy): "manual" returns
-    // a 3xx like any other response instead of following it — the ts
-    // donor's fetch honours the same key natively, and an automatic follow
-    // would carry injected credentials to a host no policy approved.
-    HttpClient.Redirect redirectPolicy =
-        "manual".equals(fetchdef.get("redirect"))
-            ? HttpClient.Redirect.NEVER
-            : HttpClient.Redirect.NORMAL;
-
-    // Honour a proxy annotation on the fetch definition (set by the proxy
-    // feature): route the request through a proxied HttpClient.
-    HttpClient.Builder clientb = HttpClient.newBuilder()
-        .followRedirects(redirectPolicy);
-    Object proxy = fetchdef.get("proxy");
-    if (proxy instanceof String && !"".equals(proxy)) {
-      try {
-        URI proxyUri = URI.create((String) proxy);
-        int port = proxyUri.getPort() < 0 ? 80 : proxyUri.getPort();
-        clientb.proxy(ProxySelector.of(new InetSocketAddress(proxyUri.getHost(), port)));
-      }
-      catch (RuntimeException e) {
-        // Unparseable proxy target: fall through to a direct connection,
-        // mirroring the go transport (bad proxy URL is ignored).
-      }
-    }
-
     HttpResponse<String> resp;
     try {
-      resp = clientb.build().send(reqb.build(), HttpResponse.BodyHandlers.ofString());
+      resp = clientFor(fetchdef).send(reqb.build(), HttpResponse.BodyHandlers.ofString());
     }
     catch (Exception e) {
       throw new RuntimeException("fetch: " + e.getMessage(), e);

package/project/.sdk/tm/java/utility/PrepareQuery.java

@@ -35,7 +35,7 @@ final class PrepareQuery {
     for (List<Object> item : Struct.items(reqmatch)) {
       String key = item.get(0) instanceof String ? (String) item.get(0) : "";
       Object val = item.get(1);
-      if (val != null && !containsStr(params, key)) {
+      if (val != null && !"$action".equals(key) && !containsStr(params, key)) {
         out.put(key, val);
       }
     }

package/project/.sdk/tm/java/utility/TransformRequest.java

@@ -19,17 +19,32 @@ final class TransformRequest {
     Map<String, Object> transform =
         Helpers.toMapAny(Struct.getprop(ctx.point, "transform"));
     if (transform == null) {
-      return ctx.reqdata;
+      return stripAction(ctx.reqdata);
     }
 
     Object reqform = Struct.getprop(transform, "req", null);
     if (reqform == null) {
-      return ctx.reqdata;
+      return stripAction(ctx.reqdata);
     }
 
     Map<String, Object> data = new LinkedHashMap<>();
     data.put("reqdata", ctx.reqdata);
 
-    return Struct.transform(data, reqform);
+    return stripAction(Struct.transform(data, reqform));
+  }
+
+  // `$action` selects the point (see MakePoint); 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 instanceof Map) || !((Map<?, ?>) reqdata).containsKey("$action")) {
+      return reqdata;
+    }
+    Map<String, Object> body = new LinkedHashMap<>();
+    for (Map.Entry<?, ?> e : ((Map<?, ?>) reqdata).entrySet()) {
+      if (!"$action".equals(e.getKey())) {
+        body.put(String.valueOf(e.getKey()), e.getValue());
+      }
+    }
+    return body;
   }
 }

package/project/.sdk/tm/js/src/Context.js

@@ -57,7 +57,13 @@ class Context {
     this.client = getprop(ctxmap, 'client', getprop(basectx, 'client'))
     this.utility = getprop(ctxmap, 'utility', getprop(basectx, 'utility'))
 
-    this.ctrl = getprop(ctxmap, 'ctrl', getprop(basectx, 'ctrl', this.ctrl))
+    // An operation gets its OWN control unless the caller passed one: a
+    // paging cursor left on the client's control would otherwise be picked
+    // up by the next, unrelated call. A context with no opname is not an
+    // operation, so it still shares (an entity's, with the client's).
+    const opname = getprop(ctxmap, 'opname')
+    const basectrl = null == opname ? getprop(basectx, 'ctrl', this.ctrl) : this.ctrl
+    this.ctrl = getprop(ctxmap, 'ctrl', basectrl)
     this.meta = getprop(ctxmap, 'meta', getprop(basectx, 'meta', this.meta))
 
     this.config = getprop(ctxmap, 'config', getprop(basectx, 'config'))
@@ -78,7 +84,6 @@ class Context {
     this.result = getprop(ctxmap, 'result', getprop(basectx, 'result'))
     this.response = getprop(ctxmap, 'response', getprop(basectx, 'response'))
 
-    const opname = getprop(ctxmap, 'opname')
     this.op = this.resolveOp(opname)
   }
 

package/project/.sdk/tm/js/src/feature/paging/PagingFeature.js

@@ -7,8 +7,9 @@ const { BaseFeature } = require('../base/BaseFeature')
 // 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-Next-Page`/`X-Total-Count` headers, or `next`/
-// `cursor`/`hasMore` fields in the body — and records them on
-// `ctx.result.paging`. Generated SDKs build auto-iteration on top of this
+// `cursor`/`hasMore` fields in the body (snake_case forms too) — and
+// records them on `ctx.result.paging` and the caller's `ctrl.paging`.
+// Generated SDKs build auto-iteration on top of this
 // (advance the cursor/page and re-issue the list call until `hasMore` is
 // false). Parameter names and page size are configurable.
 class PagingFeature extends BaseFeature {
@@ -28,7 +29,7 @@ class PagingFeature extends BaseFeature {
 
 
   PreRequest(ctx) {
-    if (!this._isList(ctx)) {
+    if (!this.active || !this._isList(ctx)) {
       return
     }
     const spec = ctx.spec
@@ -58,7 +59,10 @@ class PagingFeature extends BaseFeature {
       spec.query[cursorParam] = paging.cursor
     }
     else if (null == spec.query[pageParam]) {
-      spec.query[pageParam] = null != paging.page ? paging.page : (this._options.startPage || 1)
+      // A record written back by PreResult holds the page just fetched as
+      // `page` and the one to fetch as `nextPage`, so nextPage wins.
+      spec.query[pageParam] = null != paging.nextPage ? paging.nextPage :
+        null != paging.page ? paging.page : (this._options.startPage || 1)
     }
 
     if (null != this._options.limit && null == spec.query[limitParam]) {
@@ -68,7 +72,7 @@ class PagingFeature extends BaseFeature {
 
 
   PreResult(ctx) {
-    if (!this._isList(ctx)) {
+    if (!this.active || !this._isList(ctx)) {
       return
     }
     const result = ctx.result
@@ -124,11 +128,20 @@ class PagingFeature extends BaseFeature {
       }
     }
 
-    // Body-level cursors.
+    // Body-level signals; snake_case forms are read first so camelCase wins.
     if (body && 'object' === typeof body) {
       if (null != body.next) { paging.next = paging.next || body.next }
+      if (null != body.next_cursor) { paging.cursor = body.next_cursor }
       if (null != body.cursor) { paging.cursor = body.cursor }
       if (null != body.nextCursor) { paging.cursor = body.nextCursor }
+      if (null == paging.nextPage) {
+        const np = null != body.nextPage ? body.nextPage : body.next_page
+        if ('number' === typeof np || 'string' === typeof np) { paging.nextPage = np }
+      }
+      if ('boolean' === typeof body.has_more) {
+        paging.hasMore = body.has_more
+        explicitMore = true
+      }
       if ('boolean' === typeof body.hasMore) {
         paging.hasMore = body.hasMore
         explicitMore = true
@@ -147,6 +160,11 @@ class PagingFeature extends BaseFeature {
 
     result.paging = paging
 
+    // ctx.ctrl is the caller's own object, so the record reaches them.
+    if (null != ctx.ctrl) {
+      ctx.ctrl.paging = paging
+    }
+
     const client = this._client
     client._paging = { last: paging }
   }