@voxgig/sdkgen 4.23.0 → 4.24.0

package/project/.sdk/tm/rust/utility/fetcher.rs

@@ -1,29 +1,56 @@
+use std::collections::HashMap;
 use std::rc::Rc;
+use std::sync::{Mutex, OnceLock};
 
 use crate::core::context::Context;
 use crate::core::error::ProjectNameError;
 use crate::core::helpers::{call_vfn, get_str, getp, getpath, ja, jo, json_thunk, setp};
 use crate::utility::voxgigstruct::Value;
 
-// Default live transport: ureq (blocking, minimal). Honours a `proxy`
-// annotation on the fetch definition (set by the proxy feature) by routing
-// the request through an agent configured with that proxy.
+// One agent per process: ureq pools keep-alive connections per agent, so
+// an agent per request reused nothing. Cloning shares the pool.
+pub(crate) fn default_agent() -> ureq::Agent {
+    static AGENT: OnceLock<ureq::Agent> = OnceLock::new();
+    AGENT.get_or_init(|| ureq::AgentBuilder::new().build()).clone()
+}
+
+// Agents keyed by the `proxy` annotation (set by the proxy feature) and
+// manual redirects, for requests the default agent cannot serve.
+fn agent_for(fetchdef: &Value) -> ureq::Agent {
+    let proxy = get_str(fetchdef, "proxy").filter(|p| !p.is_empty());
+    let manual = get_str(fetchdef, "redirect").as_deref() == Some("manual");
+    if proxy.is_none() && !manual {
+        return default_agent();
+    }
+
+    static AGENTS: OnceLock<Mutex<HashMap<(Option<String>, bool), ureq::Agent>>> =
+        OnceLock::new();
+    let mut agents = AGENTS
+        .get_or_init(|| Mutex::new(HashMap::new()))
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
+    agents
+        .entry((proxy.clone(), manual))
+        .or_insert_with(|| {
+            let mut builder = ureq::AgentBuilder::new();
+            if let Some(p) = proxy.as_deref().and_then(|p| ureq::Proxy::new(p).ok()) {
+                builder = builder.proxy(p);
+            }
+            if manual {
+                builder = builder.redirects(0);
+            }
+            builder.build()
+        })
+        .clone()
+}
+
+// Default live transport: ureq (blocking, minimal).
 fn default_http_fetch(fullurl: &str, fetchdef: &Value) -> Result<Value, ProjectNameError> {
     let method = get_str(fetchdef, "method")
         .filter(|m| !m.is_empty())
         .unwrap_or_else(|| "GET".to_string());
 
-    let mut builder = ureq::AgentBuilder::new();
-    if let Some(proxy) = get_str(fetchdef, "proxy").filter(|p| !p.is_empty()) {
-        if let Ok(p) = ureq::Proxy::new(&proxy) {
-            builder = builder.proxy(p);
-        }
-    }
-    if get_str(fetchdef, "redirect").as_deref() == Some("manual") {
-        builder = builder.redirects(0);
-    }
-    let agent = builder.build();
-
+    let agent = agent_for(fetchdef);
     let mut req = agent.request(&method, fullurl);
 
     let mut has_ua = false;

package/project/.sdk/tm/rust/utility/prepare_query.rs

@@ -37,7 +37,7 @@ pub fn prepare_query_util(ctx: &Rc<Context>) -> Value {
             .map(|(k, v)| (k.clone(), v.clone()))
             .collect();
         for (key, val) in entries {
-            if !val.is_noval() && !val.is_null() && !contains(&key) {
+            if !val.is_noval() && !val.is_null() && "$action" != key && !contains(&key) {
                 setp(&out, &key, val);
             }
         }

package/project/.sdk/tm/rust/utility/transform_request.rs

@@ -1,10 +1,36 @@
 use std::rc::Rc;
 
 use crate::core::context::Context;
-use crate::core::helpers::{getp, jo, to_map};
+use crate::core::helpers::{getp, jo, setp, to_map};
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
+// `$action` selects the point (see make_point_util); it is never an API
+// field, so the body is a copy without it. The caller's map is left untouched.
+fn strip_action(reqdata: Value) -> Value {
+    let has = match &reqdata {
+        Value::Map(src) => src.borrow().contains_key("$action"),
+        _ => false,
+    };
+    if !has {
+        return reqdata;
+    }
+    let body = Value::empty_map();
+    if let Value::Map(src) = &reqdata {
+        let entries: Vec<(String, Value)> = src
+            .borrow()
+            .iter()
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect();
+        for (k, v) in entries {
+            if "$action" != k {
+                setp(&body, &k, v);
+            }
+        }
+    }
+    body
+}
+
 pub fn transform_request_util(ctx: &Rc<Context>) -> Value {
     let spec = ctx.spec.borrow().clone();
     let point = ctx.point.borrow().clone();
@@ -15,17 +41,17 @@ pub fn transform_request_util(ctx: &Rc<Context>) -> Value {
 
     let transform = to_map(&getp(&point, "transform"));
     if transform.is_noval() {
-        return ctx.reqdata.borrow().clone();
+        return strip_action(ctx.reqdata.borrow().clone());
     }
 
     let reqform = getp(&transform, "req");
     if reqform.is_noval() || reqform.is_null() {
-        return ctx.reqdata.borrow().clone();
+        return strip_action(ctx.reqdata.borrow().clone());
     }
 
     let store = jo(vec![("reqdata", ctx.reqdata.borrow().clone())]);
-    match vs::transform(&store, &reqform, None) {
+    strip_action(match vs::transform(&store, &reqform, None) {
         Ok(reqdata) => reqdata,
         Err(_) => ctx.reqdata.borrow().clone(),
-    }
+    })
 }

package/project/.sdk/tm/scala/core/Context.scala

@@ -51,7 +51,8 @@ class Context(ctxmap: JMap[String, Object], basectx: Context) {
         case c: Control => ctrl = c
         case _ =>
       }
-    } else if (basectx != null && basectx.ctrl != null) {
+    } else if (basectx != null && basectx.ctrl != null
+        && Helpers.getCtxProp(ctxmap, "opname") == null) {
       ctrl = basectx.ctrl
     }
 

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

@@ -138,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)
@@ -281,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

@@ -93,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()
@@ -206,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)
   }