@voxgig/sdkgen 4.23.0 → 4.24.1

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/test/pipeline_test.go

@@ -2,6 +2,7 @@ package sdktest
 
 
 import (
+	"regexp"
 	"testing"
 
 	sdk "GOMODULE"
@@ -464,13 +465,105 @@ func TestPipelineFeatureOrder(t *testing.T) {
 	})
 }
 
+// plAuthCookiePair matches a cookie credential as PrepareAuth writes it:
+// `<scheme>=K` for the probe key, with no scheme prefix and nothing else in
+// the bag.
+var plAuthCookiePair = regexp.MustCompile(`^[^=;]+=K$`)
+
+// plAuthCred is where this SDK's PrepareAuth actually puts the credential.
+// The name is the API's own scheme name, not always "authorization", so the
+// cases below read it from a probe run instead of asserting a name. Pair is
+// the `<scheme>=` lead-in of a COOKIE credential, which rides the header bag
+// under the key "cookie" instead of taking a header of its own.
+type plAuthCred struct {
+	where string
+	name  string
+	value any
+	pair  string
+}
+
+// plAuthBag picks the container by placement. A cookie credential rides the
+// header bag, because a cookie IS a header.
+func plAuthBag(spec *sdk.Spec, where string) map[string]any {
+	if "query" == where {
+		return spec.Query
+	}
+	return spec.Headers
+}
+
+// plAuth is the options auth block every case passes. `basic: false` is
+// explicit: an HTTP Basic API's generated config carries `auth.basic: true`,
+// and a client that merges it in takes a branch needing a secret as well.
+// With none supplied that branch writes nothing, which the probe would then
+// read as a public API.
+func plAuth(prefix string) map[string]any {
+	return map[string]any{"prefix": prefix, "basic": false}
+}
+
+// plAuthCredential runs PrepareAuth once with both containers present and
+// reports which one it wrote to, and under what name. Nil means this SDK
+// places no credential at all - a public API - which is a legitimate shape.
+func plAuthProbe(t *testing.T, sdkopts map[string]any) *plAuthCred {
+	t.Helper()
+	client, utility := plClient(t, sdkopts)
+	ctx := plCtx(client, utility, nil)
+	ctx.Spec = sdk.NewSpec(map[string]any{"step": "s"})
+	if _, err := utility.PrepareAuth(ctx); err != nil {
+		return nil
+	}
+	for _, where := range []string{"headers", "query"} {
+		for name, value := range plAuthBag(ctx.Spec, where) {
+			pair := ""
+			text, is := value.(string)
+			if "headers" == where && "cookie" == name && is &&
+				plAuthCookiePair.MatchString(text) {
+				pair = text[:len(text)-1]
+			}
+			return &plAuthCred{where: where, name: name, value: value, pair: pair}
+		}
+	}
+	return nil
+}
+
+func plAuthCredential(t *testing.T) *plAuthCred {
+	t.Helper()
+	return plAuthProbe(t, map[string]any{"apikey": "K", "auth": plAuth("Bearer")})
+}
+
+// plAuthAnyCredential is every credential this SDK could possibly place: both
+// credentials and Basic switched on, so whichever branch the API has,
+// something lands unless the API is public.
+func plAuthAnyCredential(t *testing.T) *plAuthCred {
+	t.Helper()
+	return plAuthProbe(t, map[string]any{
+		"apikey": "K",
+		"secret": "S",
+		"auth":   map[string]any{"prefix": "Bearer", "basic": true},
+	})
+}
+
 func TestPipelinePrepareAuth(t *testing.T) {
 
-	authSpec := func(headers map[string]any) *sdk.Spec {
-		if headers == nil {
-			headers = map[string]any{}
+	cred := plAuthCredential(t)
+
+	// placed runs PrepareAuth over a fresh spec, seeding the credential slot
+	// first when seed is non-nil, and reports what is left there.
+	placed := func(t *testing.T, sdkopts map[string]any, seed any) (any, bool) {
+		t.Helper()
+		client, utility := plClient(t, sdkopts)
+		ctx := plCtx(client, utility, nil)
+		ctx.Spec = sdk.NewSpec(map[string]any{"step": "s"})
+		if cred != nil && seed != nil {
+			plAuthBag(ctx.Spec, cred.where)[cred.name] = seed
+		}
+		if _, err := utility.PrepareAuth(ctx); err != nil {
+			t.Fatalf("unexpected error: %v", err)
 		}
-		return sdk.NewSpec(map[string]any{"headers": headers, "step": "s"})
+		if cred == nil {
+			return nil, false
+		}
+		value, has := plAuthBag(ctx.Spec, cred.where)[cred.name]
+		return value, has
 	}
 
 	t.Run("guards-missing-spec", func(t *testing.T) {
@@ -482,86 +575,99 @@ func TestPipelinePrepareAuth(t *testing.T) {
 		}
 	})
 
-	t.Run("apikey-with-prefix-space-joined", func(t *testing.T) {
-		client, utility := plClient(t, map[string]any{
-			"apikey": "K",
-			"auth":   map[string]any{"prefix": "Bearer"},
-		})
-		ctx := plCtx(client, utility, nil)
-		ctx.Spec = authSpec(nil)
-		if _, err := utility.PrepareAuth(ctx); err != nil {
-			t.Fatalf("unexpected error: %v", err)
+	// Without this the cases below cannot fail for an SDK whose credential the
+	// probe misses: every one of them takes the public-API path instead.
+	t.Run("probe-finds-the-credential-this-sdk-places", func(t *testing.T) {
+		if (cred == nil) != (plAuthAnyCredential(t) == nil) {
+			t.Error("the probe missed a credential this SDK places, so every " +
+				"case below takes the public-API path")
+		}
+	})
+
+	t.Run("apikey-placed-where-this-api-puts-it", func(t *testing.T) {
+		if cred == nil {
+			// A public API places nothing, and that is the whole assertion.
+			if _, has := placed(t, map[string]any{
+				"apikey": "K",
+				"auth":   plAuth("Bearer"),
+			}, nil); has {
+				t.Errorf("expected no credential placed at all")
+			}
+			return
+		}
+		if cred.where != "headers" && cred.where != "query" {
+			t.Fatalf("unexpected credential container %q", cred.where)
+		}
+		if "" != cred.pair {
+			// A cookie credential is a `<scheme>=<key>` pair, and the scheme
+			// name leaves no room for the option's prefix.
+			text, _ := cred.value.(string)
+			if !plAuthCookiePair.MatchString(text) {
+				t.Errorf("expected a cookie pair, got %v", cred.value)
+			}
+			return
+		}
+		// A header credential is prefix-joined; a query credential is the raw
+		// key, because a query parameter has nowhere to put a scheme name.
+		want := "Bearer K"
+		if "query" == cred.where {
+			want = "K"
 		}
-		if ctx.Spec.Headers["authorization"] != "Bearer K" {
-			t.Errorf("expected 'Bearer K', got %v", ctx.Spec.Headers["authorization"])
+		if cred.value != want {
+			t.Errorf("expected %q in %s[%q], got %v",
+				want, cred.where, cred.name, cred.value)
 		}
 	})
 
 	t.Run("raw-apikey-empty-prefix-as-is", func(t *testing.T) {
-		client, utility := plClient(t, map[string]any{
+		value, has := placed(t, map[string]any{
 			"apikey": "K",
-			"auth":   map[string]any{"prefix": ""},
-		})
-		ctx := plCtx(client, utility, nil)
-		ctx.Spec = authSpec(nil)
-		if _, err := utility.PrepareAuth(ctx); err != nil {
-			t.Fatalf("unexpected error: %v", err)
+			"auth":   plAuth(""),
+		}, nil)
+		if cred == nil {
+			if has {
+				t.Errorf("expected no credential placed at all")
+			}
+			return
 		}
-		if ctx.Spec.Headers["authorization"] != "K" {
-			t.Errorf("expected raw 'K', got %v", ctx.Spec.Headers["authorization"])
+		if value != cred.pair+"K" {
+			t.Errorf("expected %q, got %v", cred.pair+"K", value)
 		}
 	})
 
-	t.Run("empty-apikey-drops-header", func(t *testing.T) {
-		client, utility := plClient(t, map[string]any{
+	t.Run("empty-apikey-drops-credential", func(t *testing.T) {
+		if _, has := placed(t, map[string]any{
 			"apikey": "",
-			"auth":   map[string]any{"prefix": "Bearer"},
-		})
-		ctx := plCtx(client, utility, nil)
-		ctx.Spec = authSpec(map[string]any{"authorization": "stale"})
-		if _, err := utility.PrepareAuth(ctx); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if _, has := ctx.Spec.Headers["authorization"]; has {
-			t.Errorf("expected authorization dropped, got %v", ctx.Spec.Headers["authorization"])
+			"auth":   plAuth("Bearer"),
+		}, "stale"); has {
+			t.Errorf("expected the credential dropped")
 		}
 	})
 
-	t.Run("missing-apikey-drops-header", func(t *testing.T) {
-		client, utility := plClient(t, map[string]any{
-			"auth": map[string]any{"prefix": "Bearer"},
-		})
+	t.Run("missing-apikey-drops-credential", func(t *testing.T) {
+		sdkopts := map[string]any{"auth": plAuth("Bearer")}
+		client, _ := plClient(t, sdkopts)
 		options := client.OptionsMap()
 		if apikey, _ := options["apikey"].(string); apikey != "" {
 			t.Skip("SDK options carry a configured apikey; case not reproducible here")
 		}
-		ctx := plCtx(client, utility, nil)
-		ctx.Spec = authSpec(map[string]any{"authorization": "stale"})
-		if _, err := utility.PrepareAuth(ctx); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if _, has := ctx.Spec.Headers["authorization"]; has {
-			t.Errorf("expected authorization dropped, got %v", ctx.Spec.Headers["authorization"])
+		if _, has := placed(t, sdkopts, "stale"); has {
+			t.Errorf("expected the credential dropped")
 		}
 	})
 
-	t.Run("public-api-no-auth-block-drops-header", func(t *testing.T) {
-		client, utility := plClient(t, map[string]any{"apikey": "K"})
-		options := client.OptionsMap()
-		if options["auth"] != nil {
+	t.Run("public-api-no-auth-block-drops-credential", func(t *testing.T) {
+		sdkopts := map[string]any{"apikey": "K"}
+		client, _ := plClient(t, sdkopts)
+		if client.OptionsMap()["auth"] != nil {
 			// Option validation supplies an auth shape for this SDK, so a
 			// truly auth-less client cannot be constructed here (the ts test
 			// fakes the client object; Go's prepareAuth reads the concrete
 			// client options).
 			t.Skip("options always carry an auth block in this SDK")
 		}
-		ctx := plCtx(client, utility, nil)
-		ctx.Spec = authSpec(map[string]any{"authorization": "stale"})
-		if _, err := utility.PrepareAuth(ctx); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if _, has := ctx.Spec.Headers["authorization"]; has {
-			t.Errorf("expected authorization dropped, got %v", ctx.Spec.Headers["authorization"])
+		if _, has := placed(t, sdkopts, "stale"); has {
+			t.Errorf("expected the credential dropped")
 		}
 	})
 }

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

@@ -618,6 +618,23 @@ func TestPrimaryUtility(t *testing.T) {
 		authClient := sdk.TestSDK(nil, setupOpts)
 		authUtility := authClient.GetUtility()
 
+		// The corpus writes the credential as `headers.authorization`: a
+		// PLACEHOLDER each runner points at the container and name this API
+		// actually uses. plAuthCredential (pipeline_test.go, same package)
+		// discovers both by running PrepareAuth once.
+		cred := plAuthCredential(t)
+		if cred == nil {
+			t.Fatal("prepareAuth placed no credential in headers or query")
+		}
+
+		// An absent section is runsection's report to make, not a nil-map write.
+		if section, has := primary["prepareAuth"].(map[string]any); has &&
+			("headers" != cred.where || "authorization" != cred.name) {
+			original := section["basic"]
+			section["basic"] = retargetAuth(original, cred)
+			defer func() { section["basic"] = original }()
+		}
+
 		runsection(t, "prepareAuth", func(args ...any) (any, error) {
 			ctx := omniCtx(args[0], authClient, authUtility)
 
@@ -823,3 +840,39 @@ func makeTestFullCtx(client *sdk.ProjectNameSDK, utility *sdk.Utility) *sdk.Cont
 
 // useVS prevents unused import error
 var _ = vs.Clone
+
+
+// retargetAuth rewrites the corpus's `headers` bag to the container this
+// SDK's PrepareAuth writes to, and the `authorization` key inside it to the
+// API's own credential name. Applied only to the prepareAuth section, so
+// real header assertions elsewhere are untouched.
+func retargetAuth(node any, cred *plAuthCred) any {
+	switch value := node.(type) {
+	case map[string]any:
+		out := map[string]any{}
+		for key, child := range value {
+			if "headers" == key {
+				bag := map[string]any{}
+				inner, _ := child.(map[string]any)
+				for bagkey, bagvalue := range inner {
+					name := bagkey
+					if "authorization" == bagkey {
+						name = cred.name
+					}
+					bag[name] = retargetAuth(bagvalue, cred)
+				}
+				out[cred.where] = bag
+			} else {
+				out[key] = retargetAuth(child, cred)
+			}
+		}
+		return out
+	case []any:
+		out := make([]any, len(value))
+		for index, child := range value {
+			out[index] = retargetAuth(child, cred)
+		}
+		return out
+	}
+	return node
+}

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) {