@voxgig/sdkgen 4.22.0 → 4.24.0

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

@@ -109,18 +109,23 @@ public class TestFeature extends BaseFeature {
       return data;
     }
     String spec = (String) restf;
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (!spec.startsWith("`body.") || !spec.endsWith("`") || spec.length() < 8) {
       return data;
     }
     String inner = spec.substring(6, spec.length() - 1);
-    if (inner.isEmpty() || inner.contains(".")) {
+    if (inner.isEmpty()) {
       return data;
     }
-    Map<String, Object> wrapped = new LinkedHashMap<>();
-    wrapped.put(inner, data);
-    return wrapped;
+    String[] segs = inner.split("\\.", -1);
+    Object out = data;
+    for (int i = segs.length - 1; 0 <= i; i--) {
+      Map<String, Object> wrapped = new LinkedHashMap<>();
+      wrapped.put(segs[i], out);
+      out = wrapped;
+    }
+    return out;
   }
 
   private Map<String, Object> respond(Context ctx, int status, Object data, Map<String, Object> extra) {
@@ -223,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);
@@ -369,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 }
   }

package/project/.sdk/tm/js/src/feature/test/TestFeature.js

@@ -148,6 +148,7 @@ class TestFeature extends BaseFeature {
         const found = select(entmap, args)
         const ent = getelem(found, 0)
         if (null == ent) {
+          // update miss: 404, never another record
           return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
         else {
@@ -161,13 +162,12 @@ class TestFeature extends BaseFeature {
         const args = self.buildArgs(ctx, op, ctx.reqmatch)
         const found = select(entmap, args)
         const ent = getelem(found, 0)
-        if (null == ent) {
-          return respond(404, undefined, { statusText: S_NOT_FOUND })
-        }
-        else {
+        // Remove only the first matched entity. If nothing matches,
+        // succeed as a no-op rather than erroring.
+        if (null != ent) {
           delprop(entmap, getprop(ent, 'id'))
-          return respond(200)
         }
+        return respond(200)
       }
       else if ('create' === op.name) {
         const args = self.buildArgs(ctx, op, ctx.reqdata)
@@ -183,6 +183,8 @@ class TestFeature extends BaseFeature {
         const out = clone(ent)
         return respond(200, out)
       }
+
+      return respond(404, undefined, { statusText: 'Unknown operation' })
     }
 
     // Optional network behaviour simulation over the mock transport. Enable

package/project/.sdk/tm/js/src/utility/PrepareQueryUtility.js

@@ -13,7 +13,7 @@ function prepareQuery(ctx) {
 
   const out = {}
   for (let [key, val] of items(reqmatch)) {
-    if (null != val && !params.includes(key)) {
+    if (null != val && '$action' !== key && !params.includes(key)) {
       out[key] = val
     }
   }

package/project/.sdk/tm/js/test/feature/Corpus.test.js

@@ -254,6 +254,10 @@ describe('FeatureCorpus', () => {
 
       const probe = makeClient({})
       if (!probe._rootctx.config.hasFeature(name)) {
+        // The one line every runner prints for a section that names a
+        // feature this SDK does not generate, so an inert section is
+        // visible in the output rather than inferred from a green tick.
+        t.diagnostic(`feature.${name}: inert (this SDK does not generate the feature)`)
         return t.skip(`this SDK was generated without the ${name} feature`)
       }
 

package/project/.sdk/tm/js/test/live-entity.js

@@ -10,26 +10,26 @@ const live_runner_1 = require("./live-runner");
 const utility_1 = require("./utility");
 // The offline flow keeps its deterministic fixture assertions. Live flows
 // resolve real prerequisites per operation and collect failures until done.
-async function runLiveEntity(setup, entity, flow, accessor) {
+async function runLiveEntity(setup, entity, flow, accessor, facts = {}) {
     const { client, transport } = setup;
-    const steps = flow.step || [];
+    const steps = (flow.step || []).filter((step) => false !== step.a);
     const created = new Map();
     const listed = [];
     const marks = new Map();
     const idField = entity.id?.field || 'id';
     const copy = (value) => JSON.parse(JSON.stringify(value ?? {}));
-    const hasCreate = steps.some(step => step.op === 'create');
+    const hasCreate = steps.some(step => step.o === 'create');
     const report = await (0, live_runner_1.runLiveSteps)(steps.map((step, index) => {
-        const ref = step.input?.ref || entity.name + '_ref01';
-        const op = step.op;
+        const ref = step.i?.ref || entity.name + '_ref01';
+        const op = step.o;
         const excluded = (0, utility_1.isControlSkipped)('entityOp', entity.name + '.' + op, 'live');
         return {
             id: entity.name + '.' + op + '.' + index,
-            cleanup: op === 'remove' || (step.valid || []).some((v) => v.apply === 'ItemNotExists'),
+            cleanup: op === 'remove' || (step.v || []).some((v) => v.apply === 'ItemNotExists'),
             excluded: excluded.skip ? excluded.reason || 'Excluded by test control' : undefined,
             run: async (context) => {
                 transport.enter(context);
-                const points = entity.op?.[op]?.points || [];
+                const points = (entity.op?.[op]?.points || []).filter((point) => false !== point.a);
                 if (!points.length)
                     throw new live_runner_1.LiveBlocked('No modelled operation point');
                 const record = created.get(ref);
@@ -48,7 +48,7 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 }
                 let input = op === 'create'
                     ? copy(setup.data.new?.[entity.name]?.[ref]) : {};
-                for (const [name, binding] of Object.entries({ ...step.match, ...step.data })) {
+                for (const [name, binding] of Object.entries({ ...step.m, ...step.d })) {
                     const value = setup.idmap[binding] ?? setup.idmap[name];
                     if (undefined !== value)
                         input[name] = value;
@@ -66,22 +66,22 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 let selected;
                 const missing = new Set();
                 for (const point of points) {
-                    if (point.select?.$action !== input.$action)
+                    if (point.q?.$action !== input.$action)
                         continue;
                     const candidate = { ...input };
                     let viable = true;
-                    const params = point.args?.params || [];
-                    const query = (point.args?.query || []).filter((arg) => arg.reqd);
+                    const params = point.g?.params || [];
+                    const query = (point.g?.query || []).filter((arg) => arg.r);
                     for (const arg of [...params, ...query]) {
-                        if (undefined !== candidate[arg.name] && null !== candidate[arg.name])
+                        if (undefined !== candidate[arg.n] && null !== candidate[arg.n])
                             continue;
-                        const key = arg.name === 'id' ? entity.name + '01' : arg.name.replace(/_id$/, '') + '01';
-                        const value = setup.idmap[key] ?? setup.idmap[arg.name] ?? loaded?.[arg.name] ?? arg.example;
+                        const key = arg.n === 'id' ? entity.name + '01' : arg.n.replace(/_id$/, '') + '01';
+                        const value = setup.idmap[key] ?? setup.idmap[arg.n] ?? loaded?.[arg.n] ?? arg.ex;
                         if (undefined !== value && null !== value)
-                            candidate[arg.name] = value;
-                        else if (arg.reqd !== false) {
+                            candidate[arg.n] = value;
+                        else if (arg.r !== false) {
                             viable = false;
-                            missing.add(arg.name);
+                            missing.add(arg.n);
                         }
                     }
                     if (viable) {
@@ -93,22 +93,22 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                 if (!resolved)
                     throw new live_runner_1.LiveBlocked('No usable route; missing arguments: ' + [...missing].join(', '));
                 input = resolved;
-                if (op === 'create' && selected.contract) {
-                    const facts = JSON.parse(selected.contract.json);
-                    const request = (0, live_contract_1.requestContract)(facts);
+                if (op === 'create' && facts[selected.m + ' ' + selected.o]) {
+                    const selectedFacts = facts[selected.m + ' ' + selected.o];
+                    const request = (0, live_contract_1.requestContract)(selectedFacts);
                     if (request.schema)
-                        input = { ...(0, live_contract_1.synthesizeInput)(request.schema, facts.live?.input ?? request.example) };
-                    else if (facts.protocol === 'http')
+                        input = { ...(0, live_contract_1.synthesizeInput)(request.schema, selected.li?.input ?? request.example) };
+                    else if (selectedFacts.protocol === 'http')
                         input = {};
-                    for (const arg of selected.args?.params || [])
-                        if (resolved[arg.name] !== undefined)
-                            input[arg.name] = resolved[arg.name];
+                    for (const arg of selected.g?.params || [])
+                        if (resolved[arg.n] !== undefined)
+                            input[arg.n] = resolved[arg.n];
                 }
                 let intendedMark;
                 if (op === 'update') {
-                    for (const spec of step.spec || []) {
-                        if (spec.apply === 'TextFieldMark' && step.input?.textfield) {
-                            const mark = { name: step.input.textfield, value: spec.def.mark + '_' + setup.now };
+                    for (const spec of step.s || []) {
+                        if (spec.apply === 'TextFieldMark' && step.i?.textfield) {
+                            const mark = { name: step.i.textfield, value: spec.def.mark + '_' + setup.now };
                             input[mark.name] = mark.value;
                             intendedMark = mark;
                         }
@@ -127,7 +127,7 @@ async function runLiveEntity(setup, entity, flow, accessor) {
                     });
                     listed.splice(0, listed.length, ...data);
                     context.publish(data);
-                    for (const validation of step.valid || []) {
+                    for (const validation of step.v || []) {
                         const previous = created.get(validation.def?.ref);
                         const id = previous?.[idField] ?? previous?.id;
                         if (undefined === id)

package/project/.sdk/tm/js/test/live-scenarios.js

@@ -64,10 +64,10 @@ async function runLiveScenarios(SDK, plan, envPrefix, liveDefaults = {}) {
                 let input = request.schema ? (0, live_contract_1.synthesizeInput)(request.schema, explicit) : explicit ?? {};
                 for (const kind of ['params', 'query', 'header', 'cookie'])
                     for (const arg of point.args?.[kind] || []) {
-                        if (arg.reqd && input[arg.name] === undefined) {
-                            if (arg.example === undefined)
-                                throw new live_runner_1.LiveBlocked('Missing required argument: ' + arg.name);
-                            input[arg.name] = arg.example;
+                        if (arg.r && input[arg.n] === undefined) {
+                            if (arg.ex === undefined)
+                                throw new live_runner_1.LiveBlocked('Missing required argument: ' + arg.n);
+                            input[arg.n] = arg.ex;
                         }
                     }
                 const role = hint.auth || (point.facts.security?.length === 0 || point.facts.securitySource === 'unspecified' ? 'public' : 'account');

package/project/.sdk/tm/kotlin/core/Context.kt

@@ -76,7 +76,7 @@ class Context(ctxmap: MutableMap<String, Any?>?, basectx: Context?) {
       } else if (cv is Control) {
         this.ctrl = cv
       }
-    } else if (basectx != null) {
+    } else if (basectx != null && Helpers.getCtxProp(ctxmap, "opname") == null) {
       this.ctrl = basectx.ctrl
     }
 

package/project/.sdk/tm/kotlin/feature/PagingFeature.kt

@@ -8,8 +8,9 @@ import KOTLINPACKAGE.utility.struct.Struct
 
 // Pagination support for list operations. On the way out (PreRequest) it
 // stamps page/limit (or a cursor) into the request query; on the way back
-// (PreResult) it reads the server's pagination signals and records them on
-// `ctx.result.paging`.
+// (PreResult) it reads the server's pagination signals (camelCase and
+// snake_case body forms) and records them on `ctx.result.paging` and the
+// caller's `ctrl.paging`.
 @Suppress("UNCHECKED_CAST")
 class PagingFeature : BaseFeature("paging", "0.0.1", true) {
 
@@ -53,7 +54,9 @@ class PagingFeature : BaseFeature("paging", "0.0.1", true) {
     if (cursor != null) {
       spec.query[cursorParam] = cursor
     } else if (spec.query[pageParam] == null) {
-      val page = paging["page"]
+      // A record written back by preResult holds the page just fetched as
+      // "page" and the one to fetch as "nextPage", so nextPage wins.
+      val page = paging["nextPage"] ?: paging["page"]
       if (page != null) {
         spec.query[pageParam] = page
       } else {
@@ -166,18 +169,33 @@ class PagingFeature : BaseFeature("paging", "0.0.1", true) {
       }
     }
 
-    // Body-level cursors.
+    // Body-level signals; snake_case forms are read first so camelCase wins.
     if (body is MutableMap<*, *>) {
       val bm = body as MutableMap<String, Any?>
       if (bm["next"] != null && paging["next"] == null) {
         paging["next"] = bm["next"]
       }
+      if (bm["next_cursor"] != null) {
+        paging["cursor"] = bm["next_cursor"]
+      }
       if (bm["cursor"] != null) {
         paging["cursor"] = bm["cursor"]
       }
       if (bm["nextCursor"] != null) {
         paging["cursor"] = bm["nextCursor"]
       }
+      if (paging["nextPage"] == null) {
+        val np = bm["nextPage"] ?: bm["next_page"]
+        if (np is Number) {
+          paging["nextPage"] = np.toInt()
+        } else if (np is String) {
+          paging["nextPage"] = np
+        }
+      }
+      if (bm["has_more"] is Boolean) {
+        paging["hasMore"] = bm["has_more"]
+        explicitMore = true
+      }
       if (bm["hasMore"] is Boolean) {
         paging["hasMore"] = bm["hasMore"]
         explicitMore = true
@@ -197,6 +215,20 @@ class PagingFeature : BaseFeature("paging", "0.0.1", true) {
 
     result.paging = paging
     this.last = paging
+
+    // The Context shares the caller's paging map by reference, so refill it
+    // in place; an immutable map falls back to replacing the reference.
+    val shared = ctx.ctrl.paging
+    if (shared == null) {
+      ctx.ctrl.paging = paging
+    } else {
+      try {
+        shared.clear()
+        shared.putAll(paging)
+      } catch (e: UnsupportedOperationException) {
+        ctx.ctrl.paging = paging
+      }
+    }
   }
 
   private fun isList(ctx: Context): Boolean {