@voxgig/sdkgen 4.22.0 → 4.24.0

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

@@ -9,8 +9,8 @@ import SCALAPACKAGE.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.
@@ -65,7 +65,10 @@ class PagingFeature extends BaseFeature("paging", "0.0.1", true) {
     if (cursor != null) {
       spec.query.put(cursorParam, cursor)
     } else if (spec.query.get(pageParam) == null) {
-      val 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.
+      var page = paging.get("nextPage")
+      if (page == null) page = paging.get("page")
       if (page != null) {
         spec.query.put(pageParam, page)
       } else {
@@ -192,19 +195,37 @@ class PagingFeature extends BaseFeature("paging", "0.0.1", true) {
       case _ =>
     }
 
-    // Body-level cursors.
+    // Body-level signals; snake_case forms are read first so camelCase wins.
     body match {
       case bm0: JMap[_, _] =>
         val bm = bm0.asInstanceOf[JMap[String, Object]]
         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) {
+          var np = bm.get("nextPage")
+          if (np == null) np = bm.get("next_page")
+          np match {
+            case n: java.lang.Number => paging.put("nextPage", java.lang.Integer.valueOf(n.intValue()))
+            case s: String => paging.put("nextPage", s)
+            case _ =>
+          }
+        }
+        bm.get("has_more") match {
+          case b: java.lang.Boolean =>
+            paging.put("hasMore", b)
+            explicitMore = true
+          case _ =>
+        }
         bm.get("hasMore") match {
           case b: java.lang.Boolean =>
             paging.put("hasMore", b)
@@ -227,6 +248,22 @@ class PagingFeature extends BaseFeature("paging", "0.0.1", true) {
 
     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.
+      val shared = ctx.ctrl.paging
+      if (shared == null) {
+        ctx.ctrl.paging = paging
+      } else {
+        try {
+          shared.clear()
+          shared.putAll(paging)
+        } catch {
+          case _: UnsupportedOperationException => ctx.ctrl.paging = paging
+        }
+      }
+    }
   }
 
   private def isList(ctx: Context): Boolean = {

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

@@ -50,14 +50,18 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
     val tm = Struct.getprop(ctx.point, "transform")
     Struct.getprop(tm, "res") match {
       case spec: String =>
-        // 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
         val inner = spec.substring(6, spec.length - 1)
-        if (inner.isEmpty || inner.contains(".")) return data
-        val wrapped = new java.util.LinkedHashMap[String, Object]()
-        wrapped.put(inner, data)
-        wrapped
+        if (inner.isEmpty) return data
+        var out: Object = data
+        for (seg <- inner.split("\\.", -1).reverse) {
+          val wrapped = new java.util.LinkedHashMap[String, Object]()
+          wrapped.put(seg, out)
+          out = wrapped
+        }
+        out
       case _ => data
     }
   }
@@ -134,16 +138,10 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
       if (updateMatch.isEmpty) updateMatch = resolveMatch(ctx, new LinkedHashMap[String, Object]()).asInstanceOf[LinkedHashMap[String, Object]]
       val args = buildArgs(ctx, op, updateMatch)
       val found = Struct.select(entmap, args)
-      var ent = Struct.getelem(found, java.lang.Integer.valueOf(0))
-      if (ent == null && entmap != null) {
-        val vit = entmap.values().iterator()
-        var brk = false
-        while (vit.hasNext && !brk) {
-          vit.next() match { case e: JMap[_, _] => ent = e; brk = true; case _ => }
-        }
-      }
+      val ent = Struct.getelem(found, java.lang.Integer.valueOf(0))
+      // update miss: 404, never another record
       if (ent == null) return respond(ctx, 404, null, extra("statusText", "Not found"))
-      ent match { case m: JMap[_, _] if ctx.reqdata != null => m.asInstanceOf[JMap[String, Object]].putAll(ctx.reqdata); case _ => }
+      ent match { case _: JMap[_, _] if ctx.reqdata != null => Struct.merge(Struct.jt(ent, ctx.reqdata)); case _ => }
       Struct.delprop(ent, "$KEY")
       val out = Struct.clone(ent)
       respond(ctx, 200, out, null)
@@ -277,9 +275,14 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
       case _ =>
     }
 
-    val paramsPath = Struct.getpath(point, java.util.List.of("args", "params"))
-    val reqdParams = Struct.select(paramsPath, Struct.jm("reqd", java.lang.Boolean.TRUE))
-    val reqd = Struct.transform(reqdParams, Struct.jt("`$EACH`", "", "`$KEY.name`"))
+    // 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.
+    val reqdArgs = Struct.jt()
+    for (kind <- List("params", "query")) {
+      val argsPath = Struct.getpath(point, java.util.List.of("args", kind))
+      reqdArgs.addAll(Struct.select(argsPath, Struct.jm("reqd", java.lang.Boolean.TRUE)))
+    }
+    val reqd = Struct.transform(reqdArgs, Struct.jt("`$EACH`", "", "`$KEY.name`"))
 
     val qand = Struct.jt()
     val q = Struct.jm("`$AND`", qand)

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

@@ -3,12 +3,44 @@ package SCALAPACKAGE.utility
 import java.net.{InetSocketAddress, ProxySelector, URI}
 import java.net.http.{HttpClient, HttpRequest, HttpResponse}
 import java.util.{LinkedHashMap, List => JList, Map => JMap}
-import java.util.function.{BiFunction, Supplier}
+import java.util.concurrent.ConcurrentHashMap
+import java.util.function.{BiFunction, Function => JFunction, Supplier}
 import SCALAPACKAGE.core._
 import SCALAPACKAGE.utility.struct.Struct
 
 object 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 val clients = new ConcurrentHashMap[String, HttpClient]()
+
+  private def clientFor(fetchdef: JMap[String, Object]): HttpClient = {
+    // "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.
+    val redirectPolicy =
+      if ("manual" == fetchdef.get("redirect")) HttpClient.Redirect.NEVER
+      else HttpClient.Redirect.NORMAL
+
+    val proxy = fetchdef.get("proxy") match { case p: String => p; case _ => "" }
+
+    clients.computeIfAbsent(redirectPolicy.toString + "|" + proxy,
+      new JFunction[String, HttpClient] {
+        def apply(key: String): HttpClient = {
+          val clientb = HttpClient.newBuilder().followRedirects(redirectPolicy)
+          if (proxy != "") {
+            try {
+              val proxyUri = URI.create(proxy)
+              val port = if (proxyUri.getPort < 0) 80 else proxyUri.getPort
+              clientb.proxy(ProxySelector.of(new InetSocketAddress(proxyUri.getHost, port)))
+            } catch { case _: RuntimeException => }
+          }
+          clientb.build()
+        }
+      })
+  }
+
   def defaultHttpFetch(fullurl: String, fetchdef: JMap[String, Object]): JMap[String, Object] = {
     var method = fetchdef.get("method") match { case s: String => s; case _ => "" }
     if ("" == method) method = "GET"
@@ -40,19 +72,8 @@ object Fetcher {
     }
     if (!hasUA) reqb.setHeader("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)")
 
-    val clientb = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NORMAL)
-    fetchdef.get("proxy") match {
-      case proxy: String if proxy != "" =>
-        try {
-          val proxyUri = URI.create(proxy)
-          val port = if (proxyUri.getPort < 0) 80 else proxyUri.getPort
-          clientb.proxy(ProxySelector.of(new InetSocketAddress(proxyUri.getHost, port)))
-        } catch { case _: RuntimeException => }
-      case _ =>
-    }
-
     val resp =
-      try clientb.build().send(reqb.build(), HttpResponse.BodyHandlers.ofString())
+      try clientFor(fetchdef).send(reqb.build(), HttpResponse.BodyHandlers.ofString())
       catch { case e: Exception => throw new RuntimeException("fetch: " + e.getMessage, e) }
 
     val headers = new LinkedHashMap[String, Object]()

package/project/.sdk/tm/scala/utility/Prepare.scala

@@ -79,7 +79,7 @@ object PrepareQuery {
       val item = it.next()
       val key = item.get(0) match { case s: String => s; case _ => "" }
       val v = item.get(1)
-      if (v != null && !containsStr(params, key)) out.put(key, v)
+      if (v != null && "$action" != key && !containsStr(params, key)) out.put(key, v)
     }
     out
   }

package/project/.sdk/tm/scala/utility/Transform.scala

@@ -9,15 +9,31 @@ object TransformRequest {
     if (ctx.spec != null) ctx.spec.step = "reqform"
 
     val transform = Helpers.toMapAny(Struct.getprop(ctx.point, "transform"))
-    if (transform == null) return ctx.reqdata
+    if (transform == null) return stripAction(ctx.reqdata)
 
     val reqform = Struct.getprop(transform, "req", null)
-    if (reqform == null) return ctx.reqdata
+    if (reqform == null) return stripAction(ctx.reqdata)
 
     val data = new LinkedHashMap[String, Object]()
     data.put("reqdata", ctx.reqdata)
 
-    Struct.transform(data, reqform)
+    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 def stripAction(reqdata: Object): Object = {
+    reqdata match {
+      case src: JMap[_, _] if src.containsKey("$action") =>
+        val body = new LinkedHashMap[String, Object]()
+        val it = src.asInstanceOf[JMap[String, Object]].entrySet().iterator()
+        while (it.hasNext) {
+          val e = it.next()
+          if ("$action" != e.getKey) body.put(e.getKey, e.getValue)
+        }
+        body
+      case _ => reqdata
+    }
   }
 }
 

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Context.swift

@@ -56,7 +56,7 @@ public final class Context {
       if let e = cm.entries["explain"]?.asMap { ctrl.explain = e }
       if let a = cm.entries["actor"]?.asString { ctrl.actor = a }
       if let p = cm.entries["paging"]?.asMap { ctrl.paging = p }
-    } else if let b = basectx {
+    } else if let b = basectx, ctxProp(ctxmap, "opname") == nil {
       ctrl = b.ctrl
     }
 

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/PagingFeature.swift

@@ -2,8 +2,8 @@
 // stamps page/limit (or a cursor) into the request query; on the way back
 // (PreResult) it reads the server's pagination signals - a `Link:
 // rel="next"` header, `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body - and records
-// them on `ctx.result.paging`. A per-call cursor/page from ctrl takes
+// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case
+// forms too) - and records them on `ctx.result.paging` and `ctrl.paging`. A per-call cursor/page from ctrl takes
 // priority (used by auto-iteration). Parameter names (`pageParam`,
 // `limitParam`, `cursorParam`), the page size (`limit`) and the start page
 // (`startPage`, default 1) are configurable.
@@ -68,8 +68,11 @@ public final class PagingFeature: BaseFeature {
     } else if isNil(gp(spec.query, pageParam)) {
       var page: Value? = nil
       if let paging = paging {
+        // A record written back by preResult holds the page just fetched as
+        // "page" and the one to fetch as "nextPage", so nextPage wins.
+        let np = gp(paging, "nextPage")
         let p = gp(paging, "page")
-        if !isNil(p) { page = p }
+        if !isNil(np) { page = np } else if !isNil(p) { page = p }
       }
       spec.query.entries[pageParam] = page ?? .int(Int64(foptInt(options, "startPage", 1)))
     }
@@ -177,12 +180,16 @@ public final class PagingFeature: BaseFeature {
       }
     }
 
-    // Body-level cursors.
+    // Body-level signals; snake_case forms are read first so camelCase wins.
     if let bm = body.asMap {
       let next = gp(bm, "next")
       if !isNil(next) && isNil(gp(paging, "next")) {
         paging.entries["next"] = next
       }
+      let snakeCursor = gp(bm, "next_cursor")
+      if !isNil(snakeCursor) {
+        paging.entries["cursor"] = snakeCursor
+      }
       let cursor = gp(bm, "cursor")
       if !isNil(cursor) {
         paging.entries["cursor"] = cursor
@@ -191,6 +198,18 @@ public final class PagingFeature: BaseFeature {
       if !isNil(nextCursor) {
         paging.entries["cursor"] = nextCursor
       }
+      if isNil(gp(paging, "nextPage")) {
+        var np = gp(bm, "nextPage")
+        if isNil(np) { np = gp(bm, "next_page") }
+        switch np {
+        case .int, .double, .string: paging.entries["nextPage"] = np
+        default: break
+        }
+      }
+      if let smb = gp(bm, "has_more").asBool {
+        paging.entries["hasMore"] = .bool(smb)
+        explicitMore = true
+      }
       if let hmb = gp(bm, "hasMore").asBool {
         paging.entries["hasMore"] = .bool(hmb)
         explicitMore = true
@@ -210,6 +229,14 @@ public final class PagingFeature: BaseFeature {
 
     result.paging = paging
     last = paging
+
+    // VMap is a class, so the caller's map is refilled in place; a fresh map
+    // on ctrl never reaches the caller.
+    if let shared = ctx.ctrl.paging {
+      shared.entries = paging.entries
+    } else {
+      ctx.ctrl.paging = paging
+    }
   }
 
   private func isList(_ ctx: Context) -> Bool {

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -16,14 +16,18 @@ private func testEnvelope(_ ctx: Context, _ data: Value) -> Value {
   guard let point = ctx.point else { return data }
   guard case .map(let tm)? = point.entries["transform"] else { return data }
   guard case .string(let spec)? = tm.entries["res"] else { return data }
-  // 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.
   guard spec.hasPrefix("`body."), spec.hasSuffix("`"), spec.count >= 8 else { return data }
   let inner = String(spec.dropFirst(6).dropLast(1))
-  guard !inner.isEmpty, !inner.contains(".") else { return data }
-  let wrapped = VMap()
-  wrapped.entries[inner] = data
-  return .map(wrapped)
+  guard !inner.isEmpty else { return data }
+  var out = data
+  for seg in inner.split(separator: ".", omittingEmptySubsequences: false).reversed() {
+    let wrapped = VMap()
+    wrapped.entries[String(seg)] = out
+    out = .map(wrapped)
+  }
+  return out
 }
 
 private func testRespond(_ ctx: Context, _ status: Int, _ data: Value, _ extra: VMap?) -> Value {
@@ -89,9 +93,14 @@ private func testBuildArgs(_ ctx: Context, _ op: Operation, _ args: VMap?) -> Va
     }
   }
 
-  let paramsPath = getpath(point, jtp("args", "params"))
-  let reqdParams = select(paramsPath, .map(vm(("reqd", .bool(true)))))
-  let reqd = transform(reqdParams, jtp("`$EACH`", "", "`$KEY.name`"))
+  // 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.
+  let reqdArgs = VList()
+  for kind in ["params", "query"] {
+    let argsPath = getpath(point, jtp("args", kind))
+    reqdArgs.items.append(contentsOf: select(argsPath, .map(vm(("reqd", .bool(true))))).asList?.items ?? [])
+  }
+  let reqd = transform(.list(reqdArgs), jtp("`$EACH`", "", "`$KEY.name`"))
 
   let qand = VList()
   let q = VMap()
@@ -202,17 +211,15 @@ public final class TestFeature: BaseFeature {
         }
         let args = testBuildArgs(ctx2, op, updateMatch)
         let found = select(.map(entmap), args)
-        var ent = getelem(found, .int(0))
-        if isNil(ent) {
-          for (_, e) in entmap.entries where e.isMap { ent = e; break }
-        }
+        let ent = getelem(found, .int(0))
         if isNil(ent) {
+          // update miss: 404, never another record
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
           return testRespond(ctx2, 404, .noval, extra)
         }
-        if let entm = ent.asMap {
-          for (k, v) in ctx2.reqdata.entries { entm.entries[k] = v }
+        if ent.isMap {
+          _ = merge(.list(VList([ent, .map(ctx2.reqdata)])))
         }
         delprop(ent, .string("$KEY"))
         return testRespond(ctx2, 200, clone(ent), nil)

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/Fetcher.swift

@@ -6,7 +6,21 @@ import Foundation
 import FoundationNetworking
 #endif
 
-// Non-following twin of URLSession.shared. The station feature's
+// Cookies OFF on both sessions: the process-wide session carries the
+// process-wide cookie storage, so one call's Set-Cookie would come back on
+// the next, under a different credential. Pooling is per configuration and
+// is unaffected.
+private func cookielessConfiguration() -> URLSessionConfiguration {
+  let cfg = URLSessionConfiguration.default
+  cfg.httpCookieStorage = nil
+  cfg.httpShouldSetCookies = false
+  cfg.httpCookieAcceptPolicy = .never
+  return cfg
+}
+
+private let defaultSession = URLSession(configuration: cookielessConfiguration())
+
+// Non-following twin of defaultSession. The station feature's
 // middleware sets `redirect: manual` on the fetch definition under a
 // hosts egress policy: a 3xx must come back as a response like any
 // other, because an automatic follow would carry injected credentials
@@ -25,7 +39,8 @@ private final class ManualRedirectDelegate: NSObject, URLSessionTaskDelegate {
 }
 
 private let manualRedirectSession = URLSession(
-  configuration: .default, delegate: ManualRedirectDelegate(), delegateQueue: nil)
+  configuration: cookielessConfiguration(),
+  delegate: ManualRedirectDelegate(), delegateQueue: nil)
 
 func defaultHttpFetch(_ fullurl: String, _ fetchdef: VMap) throws -> Value {
   guard let url = URL(string: fullurl) else {
@@ -59,6 +74,10 @@ func defaultHttpFetch(_ fullurl: String, _ fetchdef: VMap) throws -> Value {
     req.setValue("Mozilla/5.0 (compatible; ProjectNameSDK/1.0)", forHTTPHeaderField: "User-Agent")
   }
 
+  // Also per request, so no store reached another way can rewrite the
+  // Cookie header set above — an `apiKey in: cookie` scheme sets one.
+  req.httpShouldHandleCookies = false
+
   final class FetchBox: @unchecked Sendable {
     var data: Data?
     var resp: URLResponse?
@@ -67,7 +86,7 @@ func defaultHttpFetch(_ fullurl: String, _ fetchdef: VMap) throws -> Value {
   let box = FetchBox()
   let sem = DispatchSemaphore(value: 0)
   let session = gp(fetchdef, "redirect").asString == "manual"
-    ? manualRedirectSession : URLSession.shared
+    ? manualRedirectSession : defaultSession
   let task = session.dataTask(with: req) { d, r, e in
     box.data = d; box.resp = r; box.err = e; sem.signal()
   }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/Prepare.swift

@@ -71,7 +71,7 @@ func prepareQueryUtil(_ ctx: Context) -> VMap {
   for item in items(.map(reqmatch)) {
     let key = item[0].asString ?? ""
     let val = item[1]
-    if !isNil(val) && !containsStr(paramnames, key) {
+    if !isNil(val) && "$action" != key && !containsStr(paramnames, key) {
       query.entries[key] = val
     }
   }

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/ResultUtil.swift

@@ -54,14 +54,25 @@ func resultHeadersUtil(_ ctx: Context) -> Result {
   return result!
 }
 
+// `$action` selects the point (see makePointUtil); it is never an API field,
+// so the body is a copy without it. The caller's map is left untouched.
+private func stripAction(_ reqdata: Value) -> Value {
+  guard let src = reqdata.asMap, src.entries["$action"] != nil else { return reqdata }
+  let body = VMap()
+  for (key, val) in src.entries where "$action" != key {
+    body.entries[key] = val
+  }
+  return .map(body)
+}
+
 func transformRequestUtil(_ ctx: Context) -> Value {
   if let sp = ctx.spec { sp.step = "reqform" }
 
-  guard let tfm = gp(ctx.point, "transform").asMap else { return .map(ctx.reqdata) }
+  guard let tfm = gp(ctx.point, "transform").asMap else { return stripAction(.map(ctx.reqdata)) }
   let reqform = gp(tfm, "req")
-  if isNil(reqform) { return .map(ctx.reqdata) }
+  if isNil(reqform) { return stripAction(.map(ctx.reqdata)) }
 
-  return transform(.map(vm(("reqdata", .map(ctx.reqdata)))), reqform)
+  return stripAction(transform(.map(vm(("reqdata", .map(ctx.reqdata)))), reqform))
 }
 
 func transformResponseUtil(_ ctx: Context) -> Value {

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

@@ -58,7 +58,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'))
@@ -79,7 +85,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/ts/src/feature/paging/PagingFeature.ts

@@ -22,7 +22,7 @@ class PagingFeature extends BaseFeature {
 
 
   PreRequest(this: any, ctx: any) {
-    if (!this._isList(ctx)) {
+    if (!this.active || !this._isList(ctx)) {
       return
     }
     const spec = ctx.spec
@@ -51,7 +51,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]) {
@@ -61,7 +64,7 @@ class PagingFeature extends BaseFeature {
 
 
   PreResult(this: any, ctx: any) {
-    if (!this._isList(ctx)) {
+    if (!this.active || !this._isList(ctx)) {
       return
     }
     const result = ctx.result
@@ -118,8 +121,17 @@ class PagingFeature extends BaseFeature {
 
     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
@@ -138,6 +150,10 @@ class PagingFeature extends BaseFeature {
 
     result.paging = paging
 
+    if (null != ctx.ctrl) {
+      ctx.ctrl.paging = paging
+    }
+
     const client: any = this._client
     client._paging = { last: paging }
   }

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

@@ -193,6 +193,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 {
@@ -237,6 +238,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/ts/src/utility/PrepareQueryUtility.ts

@@ -16,7 +16,7 @@ function prepareQuery(ctx: Context) {
 
   const out: any = {}
   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/ts/test/feature/Corpus.test.ts

@@ -206,6 +206,7 @@ describe('FeatureCorpus', () => {
 
       const probe: any = makeClient({})
       if (!probe._rootctx.config.hasFeature(name)) {
+        t.diagnostic(`feature.${name}: inert (this SDK does not generate the feature)`)
         return t.skip(`this SDK was generated without the ${name} feature`)
       }