@voxgig/sdkgen 4.23.0 → 4.24.1

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/test/PipelineTest.java

@@ -11,7 +11,6 @@ package JAVAPACKAGE.sdktest;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -23,6 +22,7 @@ import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.regex.Pattern;
 
 import org.junit.jupiter.api.Test;
 
@@ -529,13 +529,98 @@ public class PipelineTest {
 
   // --- prepareAuth --------------------------------------------------------------
 
-  static Spec authSpec(Map<String, Object> headers) {
+  // A cookie credential as prepareAuth writes it: `<scheme>=K` for the probe
+  // key, with no scheme prefix and nothing else in the bag.
+  static final Pattern COOKIE_PAIR = Pattern.compile("^[^=;]+=K$");
+
+  static Spec authSpec() {
     Map<String, Object> m = new LinkedHashMap<>();
-    m.put("headers", headers == null ? new LinkedHashMap<>() : headers);
+    m.put("headers", new LinkedHashMap<String, Object>());
+    m.put("query", new LinkedHashMap<String, Object>());
     m.put("step", "s");
     return new Spec(m);
   }
 
+  // Where this SDK's prepareAuth actually puts the credential. The name is
+  // the API's OWN scheme name, not always "authorization", so it is
+  // discovered rather than asserted. `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.
+  record AuthCred(String where, String name, Object value, String pair) {
+  }
+
+  // A cookie credential rides the header bag, because a cookie IS a header.
+  static Map<String, Object> authBag(Spec spec, String where) {
+    return "query".equals(where) ? spec.query : spec.headers;
+  }
+
+  // `basic: false` is explicit: an HTTP Basic API's generated config carries
+  // `auth.basic: true`, testSDK merges it in, and the branch it selects needs
+  // a secret as well. With none supplied that branch deliberately writes
+  // nothing, which the probe below would read as a public API.
+  static Map<String, Object> authBlock(String prefix) {
+    return fhMap("prefix", prefix, "basic", Boolean.FALSE);
+  }
+
+  // Run prepareAuth with both containers present and see which one the
+  // generated utility writes to, and under what name. Null means this SDK
+  // places no credential at all - a public API - which is a legitimate
+  // shape, and the tests below assert exactly that instead.
+  static AuthCred authProbe(Map<String, Object> sdkopts) {
+    ProjectNameSDK client = plClient(sdkopts);
+    Utility utility = client.getUtility();
+    Context ctx = plCtx(client, utility, null);
+    ctx.spec = authSpec();
+    utility.prepareAuth.apply(ctx);
+    for (String where : new String[] { "headers", "query" }) {
+      for (Map.Entry<String, Object> entry : authBag(ctx.spec, where).entrySet()) {
+        Object value = entry.getValue();
+        String pair = "";
+        if ("headers".equals(where) && "cookie".equals(entry.getKey())
+            && value instanceof String
+            && COOKIE_PAIR.matcher((String) value).matches()) {
+          String text = (String) value;
+          pair = text.substring(0, text.length() - 1);
+        }
+        return new AuthCred(where, entry.getKey(), value, pair);
+      }
+    }
+    return null;
+  }
+
+  static AuthCred authCredential() {
+    return authProbe(fhMap("apikey", "K", "auth", authBlock("Bearer")));
+  }
+
+  // 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.
+  static AuthCred authAnyCredential() {
+    return authProbe(fhMap(
+        "apikey", "K",
+        "secret", "S",
+        "auth", fhMap("prefix", "Bearer", "basic", Boolean.TRUE)));
+  }
+
+  // Runs prepareAuth over a fresh spec, seeding the credential slot first
+  // when seed is non-null, and reports what is left there.
+  static Object[] authPlaced(Map<String, Object> sdkopts, Object seed) {
+    AuthCred cred = authCredential();
+    ProjectNameSDK client = plClient(sdkopts);
+    Utility utility = client.getUtility();
+    Context ctx = plCtx(client, utility, null);
+    ctx.spec = authSpec();
+    if (cred != null && seed != null) {
+      authBag(ctx.spec, cred.where()).put(cred.name(), seed);
+    }
+    utility.prepareAuth.apply(ctx);
+    if (cred == null) {
+      return new Object[] { null, Boolean.FALSE };
+    }
+    Map<String, Object> bag = authBag(ctx.spec, cred.where());
+    return new Object[] { bag.get(cred.name()), bag.containsKey(cred.name()) };
+  }
+
   @Test
   public void prepareAuth_guardsMissingSpec() {
     ProjectNameSDK client = plClient(fhMap("apikey", "K"));
@@ -545,74 +630,82 @@ public class PipelineTest {
     assertEquals("auth_no_spec", errCodeOf(() -> utility.prepareAuth.apply(ctx)));
   }
 
+  // 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.
   @Test
-  public void prepareAuth_apikeyWithPrefixSpaceJoined() {
-    ProjectNameSDK client = plClient(fhMap(
-        "apikey", "K",
-        "auth", fhMap("prefix", "Bearer")));
-    Utility utility = client.getUtility();
-    Context ctx = plCtx(client, utility, null);
-    ctx.spec = authSpec(null);
-    utility.prepareAuth.apply(ctx);
-    assertEquals("Bearer K", ctx.spec.headers.get("authorization"));
+  public void prepareAuth_probeFindsTheCredentialThisSdkPlaces() {
+    assertEquals(null == authCredential(), null == authAnyCredential(),
+        "the probe missed a credential this SDK places, so every case "
+        + "takes the public-API path");
+  }
+
+  @Test
+  public void prepareAuth_placedWhereThisApiPutsIt() {
+    AuthCred cred = authCredential();
+    if (cred == null) {
+      // A public API places nothing, and that is the whole assertion.
+      Object[] got = authPlaced(fhMap(
+          "apikey", "K",
+          "auth", authBlock("Bearer")), null);
+      assertFalse((Boolean) got[1], "expected no credential placed at all");
+      return;
+    }
+    assertTrue("headers".equals(cred.where()) || "query".equals(cred.where()),
+        "unexpected credential container " + cred.where());
+    if (!"".equals(cred.pair())) {
+      // A cookie credential is a `<scheme>=<key>` pair, and the scheme name
+      // leaves no room for the option's prefix.
+      assertTrue(COOKIE_PAIR.matcher(String.valueOf(cred.value())).matches(),
+          "expected a cookie pair, got " + 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.
+    assertEquals("query".equals(cred.where()) ? "K" : "Bearer K", cred.value());
   }
 
   @Test
   public void prepareAuth_rawApikeyEmptyPrefixAsIs() {
-    ProjectNameSDK client = plClient(fhMap(
+    Object[] got = authPlaced(fhMap(
         "apikey", "K",
-        "auth", fhMap("prefix", "")));
-    Utility utility = client.getUtility();
-    Context ctx = plCtx(client, utility, null);
-    ctx.spec = authSpec(null);
-    utility.prepareAuth.apply(ctx);
-    assertEquals("K", ctx.spec.headers.get("authorization"));
+        "auth", authBlock("")), null);
+    AuthCred cred = authCredential();
+    if (cred == null) {
+      assertFalse((Boolean) got[1], "expected no credential placed at all");
+      return;
+    }
+    assertEquals(cred.pair() + "K", got[0]);
   }
 
   @Test
-  public void prepareAuth_emptyApikeyDropsHeader() {
-    ProjectNameSDK client = plClient(fhMap(
+  public void prepareAuth_emptyApikeyDropsCredential() {
+    Object[] got = authPlaced(fhMap(
         "apikey", "",
-        "auth", fhMap("prefix", "Bearer")));
-    Utility utility = client.getUtility();
-    Context ctx = plCtx(client, utility, null);
-    ctx.spec = authSpec(fhMap("authorization", "stale"));
-    utility.prepareAuth.apply(ctx);
-    assertFalse(ctx.spec.headers.containsKey("authorization"),
-        "expected authorization dropped");
+        "auth", authBlock("Bearer")), "stale");
+    assertFalse((Boolean) got[1], "expected the credential dropped");
   }
 
   @Test
-  public void prepareAuth_missingApikeyDropsHeader() {
-    ProjectNameSDK client = plClient(fhMap(
-        "auth", fhMap("prefix", "Bearer")));
-    Map<String, Object> options = client.optionsMap();
-    Object apikey = options.get("apikey");
+  public void prepareAuth_missingApikeyDropsCredential() {
+    Map<String, Object> sdkopts = fhMap("auth", authBlock("Bearer"));
+    Object apikey = plClient(sdkopts).optionsMap().get("apikey");
     if (apikey instanceof String && !"".equals(apikey)) {
       // SDK options carry a configured apikey; case not reproducible here.
       return;
     }
-    Utility utility = client.getUtility();
-    Context ctx = plCtx(client, utility, null);
-    ctx.spec = authSpec(fhMap("authorization", "stale"));
-    utility.prepareAuth.apply(ctx);
-    assertFalse(ctx.spec.headers.containsKey("authorization"),
-        "expected authorization dropped");
+    Object[] got = authPlaced(sdkopts, "stale");
+    assertFalse((Boolean) got[1], "expected the credential dropped");
   }
 
   @Test
-  public void prepareAuth_publicApiNoAuthBlockDropsHeader() {
-    ProjectNameSDK client = plClient(fhMap("apikey", "K"));
-    Map<String, Object> options = client.optionsMap();
-    if (options.get("auth") != null) {
+  public void prepareAuth_publicApiNoAuthBlockDropsCredential() {
+    Map<String, Object> sdkopts = fhMap("apikey", "K");
+    if (plClient(sdkopts).optionsMap().get("auth") != null) {
       // Option validation supplies an auth shape for this SDK, so a truly
       // auth-less client cannot be constructed here.
       return;
     }
-    Utility utility = client.getUtility();
-    Context ctx = plCtx(client, utility, null);
-    ctx.spec = authSpec(fhMap("authorization", "stale"));
-    utility.prepareAuth.apply(ctx);
-    assertNull(ctx.spec.headers.get("authorization"), "expected authorization dropped");
+    Object[] got = authPlaced(sdkopts, "stale");
+    assertFalse((Boolean) got[1], "expected the credential dropped");
   }
 }

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

@@ -100,6 +100,44 @@ public class PrimaryUtilityTest {
     run.runset(basic, subject);
   }
 
+  // Rename the corpus's `headers` bag to the real container, and the
+  // `authorization` key inside it to the real credential name. Applied only
+  // to the prepareAuth section, so real header assertions elsewhere are
+  // untouched.
+  @SuppressWarnings("unchecked")
+  static Object retargetAuth(Object node, PipelineTest.AuthCred cred) {
+    if (node instanceof List) {
+      List<Object> out = new ArrayList<>();
+      for (Object child : (List<Object>) node) {
+        out.add(retargetAuth(child, cred));
+      }
+      return out;
+    }
+    if (!(node instanceof Map)) {
+      return node;
+    }
+
+    Map<String, Object> out = new LinkedHashMap<>();
+    for (Map.Entry<String, Object> entry : ((Map<String, Object>) node).entrySet()) {
+      if ("headers".equals(entry.getKey())) {
+        Map<String, Object> bag = new LinkedHashMap<>();
+        Map<String, Object> inner = Helpers.toMapAny(entry.getValue());
+        if (inner != null) {
+          for (Map.Entry<String, Object> bagentry : inner.entrySet()) {
+            String name = "authorization".equals(bagentry.getKey())
+                ? cred.name() : bagentry.getKey();
+            bag.put(name, retargetAuth(bagentry.getValue(), cred));
+          }
+        }
+        out.put(cred.where(), bag);
+      }
+      else {
+        out.put(entry.getKey(), retargetAuth(entry.getValue(), cred));
+      }
+    }
+    return out;
+  }
+
   // Helper: create basic test context.
   static Context makeTestCtx(ProjectNameSDK client, Utility utility,
       Map<String, Object> overrides) {
@@ -684,15 +722,38 @@ public class PrimaryUtilityTest {
     ProjectNameSDK authClient = ProjectNameSDK.testSDK(null, setupOpts);
     Utility authUtility = authClient.getUtility();
 
-    runsection("prepareAuth", (args) -> {
-      Context ctx = OmniResolver.omniCtx(args[0], authClient, authUtility);
+    // The corpus writes the credential as `headers.authorization`: a
+    // PLACEHOLDER each runner points at the container and name this API
+    // actually uses. PipelineTest.authCredential (same package) discovers
+    // both by running prepareAuth once.
+    PipelineTest.AuthCred cred = PipelineTest.authCredential();
+    assertNotNull(cred, "prepareAuth placed no credential in headers or query");
+
+    // An absent section is runsection's report to make.
+    Map<String, Object> section = Helpers.toMapAny(run().spec.get("prepareAuth"));
+    boolean swap = section != null
+        && (!"headers".equals(cred.where()) || !"authorization".equals(cred.name()));
+    Object original = swap ? section.get("basic") : null;
+    if (swap) {
+      section.put("basic", retargetAuth(original, cred));
+    }
 
-      authUtility.prepareAuth.apply(ctx);
+    try {
+      runsection("prepareAuth", (args) -> {
+        Context ctx = OmniResolver.omniCtx(args[0], authClient, authUtility);
 
-      OmniResolver.omniSyncCtx(args[0], ctx);
+        authUtility.prepareAuth.apply(ctx);
 
-      return null;
-    });
+        OmniResolver.omniSyncCtx(args[0], ctx);
+
+        return null;
+      });
+    }
+    finally {
+      if (swap) {
+        section.put("basic", original);
+      }
+    }
   }
 
   @Test

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