@voxgig/sdkgen 4.23.0 → 4.24.1

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/pipeline.test.js

@@ -323,45 +323,111 @@ describe('pipeline:feature order', () => {
 })
 
 
+// A cookie credential as prepareAuth writes it: `<scheme>=K` for the probe
+// key, with no scheme prefix and nothing else in the bag.
+const COOKIE_PAIR = /^[^=;]+=K$/
+
+
 describe('pipeline:prepareAuth', () => {
 
   // Fake client so the exact options.auth / apikey shape is controlled.
-  function authCtx(options, headers) {
-    return base({ client: { options: () => options }, spec: headers == null ? null : { headers } })
+  function authCtx(options, spec) {
+    return base({ client: { options: () => options }, spec })
+  }
+
+  function bags() {
+    return { headers: {}, query: {} }
+  }
+
+  // `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 that
+  // needs a secret as well. With none supplied that branch deliberately
+  // writes nothing, which the probe below would read as a public API.
+  function auth(prefix) {
+    return { prefix, basic: 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.
+  //
+  // `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.
+  function probe(options) {
+    const ctx = authCtx(options, bags())
+    stdutil.prepareAuth(ctx)
+    for (const where of ['headers', 'query']) {
+      const name = Object.keys(ctx.spec[where])[0]
+      if (null == name) continue
+      const value = ctx.spec[where][name]
+      const pair = 'headers' === where && 'cookie' === name
+        && COOKIE_PAIR.test(String(value))
+        ? String(value).slice(0, -1)
+        : ''
+      return { where, name, value, pair }
+    }
+    return null
+  }
+
+  const CRED = probe({ apikey: 'K', auth: auth('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.
+  const ANY = probe({ apikey: 'K', secret: 'S', auth: { prefix: 'Bearer', basic: true } })
+
+  function placed(options, seed) {
+    const spec = bags()
+    if (null != CRED && null != seed) spec[CRED.where][CRED.name] = seed
+    const ctx = authCtx(options, spec)
+    stdutil.prepareAuth(ctx)
+    return null == CRED ? undefined : ctx.spec[CRED.where][CRED.name]
   }
 
   test('guards a missing spec', () => {
-    strictEqual(stdutil.prepareAuth(authCtx({ auth: { prefix: '' }, apikey: 'K' }, null)).code, 'auth_no_spec')
+    strictEqual(stdutil.prepareAuth(authCtx({ auth: auth(''), apikey: 'K' }, null)).code, 'auth_no_spec')
   })
 
-  test('an apikey with a prefix is space-joined', () => {
-    const ctx = authCtx({ apikey: 'K', auth: { prefix: 'Bearer' } }, {})
-    stdutil.prepareAuth(ctx)
-    strictEqual(ctx.spec.headers.authorization, 'Bearer K')
+  // 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('the probe finds the credential this SDK places', () => {
+    strictEqual(null != CRED, null != ANY)
+  })
+
+  test('the apikey is placed where this API puts it', () => {
+    if (null == CRED) {
+      // A public API places nothing, and that is the whole assertion.
+      strictEqual(placed({ apikey: 'K', auth: auth('Bearer') }), undefined)
+      return
+    }
+    ok('headers' === CRED.where || 'query' === 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.
+      ok(COOKIE_PAIR.test(String(CRED.value)), String(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.
+    strictEqual(CRED.value, 'headers' === CRED.where ? 'Bearer K' : 'K')
   })
 
   test('a raw apikey (empty prefix) goes in as-is', () => {
-    const ctx = authCtx({ apikey: 'K', auth: { prefix: '' } }, {})
-    stdutil.prepareAuth(ctx)
-    strictEqual(ctx.spec.headers.authorization, 'K')
+    const raw = null == CRED ? undefined : CRED.pair + 'K'
+    strictEqual(placed({ apikey: 'K', auth: auth('') }), raw)
   })
 
-  test('an empty apikey drops the header', () => {
-    const ctx = authCtx({ apikey: '', auth: { prefix: 'Bearer' } }, { authorization: 'stale' })
-    stdutil.prepareAuth(ctx)
-    strictEqual(ctx.spec.headers.authorization, undefined)
+  test('an empty apikey drops the credential', () => {
+    strictEqual(placed({ apikey: '', auth: auth('Bearer') }, 'stale'), undefined)
   })
 
-  test('a public API (no auth block) drops the header', () => {
-    const ctx = authCtx({ apikey: 'K' }, { authorization: 'stale' })
-    stdutil.prepareAuth(ctx)
-    strictEqual(ctx.spec.headers.authorization, undefined)
+  test('a public API (no auth block) drops the credential', () => {
+    strictEqual(placed({ apikey: 'K' }, 'stale'), undefined)
   })
 
-  test('a missing apikey option drops the header', () => {
-    const ctx = authCtx({ auth: { prefix: 'Bearer' } }, { authorization: 'stale' })
-    stdutil.prepareAuth(ctx)
-    strictEqual(ctx.spec.headers.authorization, undefined)
+  test('a missing apikey option drops the credential', () => {
+    strictEqual(placed({ auth: auth('Bearer') }, 'stale'), undefined)
   })
 })
 

package/project/.sdk/tm/js/test/utility/PrimaryUtility.test.js

@@ -79,10 +79,56 @@ describe('PrimaryUtility', async () => {
   })
 
 
+  function credential() {
+    const ctx = {
+      utility,
+      // `basic: false`: a Basic API's config defaults it true, and the
+      // branch it selects needs a secret, so the probe would find nothing.
+      client: { options: () => ({ apikey: 'PROBE', auth: { prefix: '', basic: false } }) },
+      spec: { headers: {}, query: {} },
+      error: (code, msg) => Object.assign(new Error(msg), { code }),
+    }
+    try { utility.prepareAuth(ctx) } catch (e) { return null }
+    for (const where of ['headers', 'query']) {
+      const name = Object.keys(ctx.spec[where] || {})[0]
+      if (null != name) return { where, name }
+    }
+    return null
+  }
+
+  // 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.
+  function retarget(node, cred) {
+    if (null == node || 'object' !== typeof node) return node
+    if (Array.isArray(node)) return node.map((n) => retarget(n, cred))
+    const out = {}
+    for (const key of Object.keys(node)) {
+      if ('headers' === key) {
+        const bag = {}
+        for (const bk of Object.keys(node[key] || {})) {
+          bag['authorization' === bk ? cred.name : bk] = retarget(node[key][bk], cred)
+        }
+        out[cred.where] = bag
+      }
+      else out[key] = retarget(node[key], cred)
+    }
+    return out
+  }
+
   test('auth-basic', async () => {
     const sdkopts = spec.prepareAuth?.DEF?.setup?.a || {}
     const authClient = SDK.test({}, sdkopts)
-    await runset(spec.prepareAuth.basic, (ctx) => {
+
+    const cred = credential()
+    ok(null != cred, 'prepareAuth placed no credential in headers or query')
+
+    const cases = 'headers' === cred.where && 'authorization' === cred.name
+      ? spec.prepareAuth.basic
+      : retarget(spec.prepareAuth.basic, cred)
+
+    await runset(cases, (ctx) => {
       ctx.client = authClient
       fixctx(ctx)
       return utility.prepareAuth(ctx)

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 {

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

@@ -160,20 +160,13 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
         }
         val args = buildArgs(ctx, op, updateMatch)
         val found = Struct.select(entmap, args)
-        var ent = Struct.getelem(found, 0, null)
-        if (ent == null) {
-          for (e in entmap.values) {
-            if (e is MutableMap<*, *>) {
-              ent = e
-              break
-            }
-          }
-        }
+        val ent = Struct.getelem(found, 0, null)
         if (ent == null) {
+          // update miss: 404, never another record
           return respond(ctx, 404, null, extra("statusText", "Not found"))
         }
         if (ent is MutableMap<*, *>) {
-          (ent as MutableMap<String, Any?>).putAll(reqdata)
+          Struct.merge(Struct.jt(ent, reqdata))
         }
         Struct.delprop(ent, "\$KEY")
         val out = Struct.clone(ent)
@@ -320,10 +313,14 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
       }
     }
 
-    // Get required params.
-    val paramsPath = Struct.getpath(point, listOf("args", "params"))
-    val reqdParams = Struct.select(paramsPath, Struct.jm("reqd", 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 in listOf("params", "query")) {
+      val argsPath = Struct.getpath(point, listOf("args", kind))
+      reqdArgs.addAll(Struct.select(argsPath, Struct.jm("reqd", 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/kotlin/utility/Fetcher.kt

@@ -6,12 +6,44 @@ import java.net.URI
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
+import java.util.concurrent.ConcurrentHashMap
 import java.util.function.BiFunction
 import java.util.function.Supplier
 
 import KOTLINPACKAGE.core.Context
 import KOTLINPACKAGE.utility.struct.Struct
 
+// 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 = ConcurrentHashMap<String, HttpClient>()
+
+private fun clientFor(fetchdef: MutableMap<String, Any?>): 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["redirect"]) HttpClient.Redirect.NEVER
+    else HttpClient.Redirect.NORMAL
+
+  val praw = fetchdef["proxy"]
+  val proxy = if (praw is String) praw else ""
+
+  return clients.computeIfAbsent("$redirectPolicy|$proxy") {
+    val clientb = HttpClient.newBuilder().followRedirects(redirectPolicy)
+    if ("" != proxy) {
+      try {
+        val proxyUri = URI.create(proxy)
+        val port = if (proxyUri.port < 0) 80 else proxyUri.port
+        clientb.proxy(ProxySelector.of(InetSocketAddress(proxyUri.host, port)))
+      } catch (e: RuntimeException) {
+        // Unparseable proxy target: direct connection, as the go transport.
+      }
+    }
+    clientb.build()
+  }
+}
+
 @Suppress("UNCHECKED_CAST")
 fun defaultHttpFetch(fullurl: String, fetchdef: MutableMap<String, Any?>): MutableMap<String, Any?> {
   var method = if (fetchdef["method"] is String) fetchdef["method"] as String else ""
@@ -50,32 +82,9 @@ fun defaultHttpFetch(fullurl: String, fetchdef: MutableMap<String, Any?>): Mutab
     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.
-  val redirectPolicy =
-    if ("manual" == fetchdef["redirect"]) HttpClient.Redirect.NEVER
-    else HttpClient.Redirect.NORMAL
-
-  // Honour a proxy annotation on the fetch definition (set by the proxy
-  // feature): route the request through a proxied HttpClient.
-  val clientb = HttpClient.newBuilder().followRedirects(redirectPolicy)
-  val proxy = fetchdef["proxy"]
-  if (proxy is String && "" != proxy) {
-    try {
-      val proxyUri = URI.create(proxy)
-      val port = if (proxyUri.port < 0) 80 else proxyUri.port
-      clientb.proxy(ProxySelector.of(InetSocketAddress(proxyUri.host, port)))
-    } catch (e: RuntimeException) {
-      // Unparseable proxy target: fall through to a direct connection.
-    }
-  }
-
   val resp: HttpResponse<String>
   try {
-    resp = clientb.build().send(reqb.build(), HttpResponse.BodyHandlers.ofString())
+    resp = clientFor(fetchdef).send(reqb.build(), HttpResponse.BodyHandlers.ofString())
   } catch (e: Exception) {
     throw RuntimeException("fetch: " + e.message, e)
   }

package/project/.sdk/tm/kotlin/utility/Prepare.kt

@@ -194,7 +194,7 @@ fun prepareQuery(ctx: Context): MutableMap<String, Any?> {
   for (item in Struct.items(reqmatch)) {
     val key = if (item[0] is String) item[0] as String else ""
     val v = item[1]
-    if (v != null && !containsStr(params, key)) {
+    if (v != null && "\$action" != key && !containsStr(params, key)) {
       out[key] = v
     }
   }

package/project/.sdk/tm/kotlin/utility/ResultTransform.kt

@@ -58,21 +58,36 @@ fun resultHeaders(ctx: Context): KOTLINPACKAGE.core.Result {
   return result!!
 }
 
+// `$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 fun stripAction(reqdata: Any?): Any? {
+  if (reqdata !is Map<*, *> || !reqdata.containsKey("\$action")) {
+    return reqdata
+  }
+  val body = linkedMapOf<String, Any?>()
+  for ((k, v) in reqdata) {
+    if ("\$action" != k) {
+      body[k.toString()] = v
+    }
+  }
+  return body
+}
+
 fun transformRequest(ctx: Context): Any? {
   if (ctx.spec != null) {
     ctx.spec!!.step = "reqform"
   }
 
   val transform = Helpers.toMapAny(Struct.getprop(ctx.point, "transform"))
-    ?: return ctx.reqdata
+    ?: return stripAction(ctx.reqdata)
 
   val reqform = Struct.getprop(transform, "req", null)
-    ?: return ctx.reqdata
+    ?: return stripAction(ctx.reqdata)
 
   val data = linkedMapOf<String, Any?>()
   data["reqdata"] = ctx.reqdata
 
-  return Struct.transform(data, reqform)
+  return stripAction(Struct.transform(data, reqform))
 }
 
 fun transformResponse(ctx: Context): Any? {

package/project/.sdk/tm/lua/core/context.lua

@@ -49,7 +49,14 @@ function Context.new(ctxmap, basectx)
     if type(ctrl_raw.explain) == "table" then
       self.ctrl.explain = ctrl_raw.explain
     end
-  elseif basectx ~= nil and basectx.ctrl ~= nil then
+    if ctrl_raw.actor ~= nil then
+      self.ctrl.actor = ctrl_raw.actor
+    end
+    if type(ctrl_raw.paging) == "table" then
+      self.ctrl.paging = ctrl_raw.paging
+    end
+  elseif basectx ~= nil and basectx.ctrl ~= nil
+      and helpers.get_ctx_prop(ctxmap, "opname") == nil then
     self.ctrl = basectx.ctrl
   end
 

package/project/.sdk/tm/lua/core/control.lua

@@ -10,6 +10,9 @@ function Control.new(opts)
   self.throw_err = opts.throw_err
   self.err = nil
   self.explain = opts.explain
+  -- Per-call feature inputs (audit actor, paging cursor/page).
+  self.actor = opts.actor
+  self.paging = opts.paging
   return self
 end