@voxgig/sdkgen 4.33.0 → 4.34.1

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

@@ -64,6 +64,64 @@ object MakeError {
 }
 
 object MakePoint {
+  private val PathParam = "\\{([^{}/]+)\\}".r
+
+  // A terminal parameter marks a record route (/boards/{id}); a
+  // cross-reference ends in the relationship's name (/posts/{id}/author).
+  // Failing that, the shallower path wins. The same rule runs at generation
+  // time, in helpers/opShape.ts — both sides must move together.
+  private def partsLen(p: JMap[String, Object]): Int =
+    Struct.getprop(p, "parts") match {
+      case parts: JList[_] => parts.size()
+      case _ => 0
+    }
+
+  private def terminalParam(p: JMap[String, Object]): Boolean =
+    Struct.getprop(p, "parts") match {
+      case parts: JList[_] if parts.size() > 0 =>
+        parts.get(parts.size() - 1) match {
+          case s: String => s.startsWith("{")
+          case _ => false
+        }
+      case _ => false
+    }
+
+  private def ownPoint(points: Seq[JMap[String, Object]]): JMap[String, Object] = {
+    var best = points.head
+    for (cand <- points) {
+      val candTerm = terminalParam(cand)
+      val bestTerm = terminalParam(best)
+      if (candTerm != bestTerm) {
+        if (candTerm) best = cand
+      } else if (partsLen(cand) < partsLen(best)) {
+        best = cand
+      }
+    }
+    best
+  }
+
+  // The path parameters of a point that neither the call nor the entity gives
+  // a value for, looked up as param looks them up.
+  private def unfilled(ctx: Context, point: JMap[String, Object]): Seq[String] =
+    Struct.getprop(point, "parts") match {
+      case parts: JList[_] =>
+        val missing = scala.collection.mutable.ArrayBuffer[String]()
+        val it = parts.iterator()
+        while (it.hasNext) {
+          it.next() match {
+            case text: String =>
+              text match {
+                case PathParam(name) =>
+                  if (Param.value(ctx, point, name) == null) missing += name
+                case _ =>
+              }
+            case _ =>
+          }
+        }
+        missing.toSeq
+      case _ => Seq.empty
+    }
+
   def makePoint(ctx: Context): JMap[String, Object] = {
     val outPoint = ctx.out.get("point")
     if (outPoint != null) {
@@ -79,8 +137,9 @@ object MakePoint {
     val op = ctx.op
     val options = ctx.options
 
-    val allowOp = Struct.getpath(options, java.util.List.of("allow", "op")) match { case s: String => s; case _ => "" }
-    if (!allowOp.contains(op.name)) {
+    val allowOpRaw = Struct.getpath(options, java.util.List.of("allow", "op"))
+    val allowOp = allowOpRaw match { case s: String => s; case _ => "" }
+    if (!Helpers.allowed(allowOpRaw, op.name)) {
       throw ctx.makeError("point_op_allow",
         "Operation \"" + op.name + "\" not allowed by SDK option allow.op value: \"" + allowOp + "\"")
     }
@@ -146,39 +205,25 @@ object MakePoint {
               Struct.stringify(unmatchedAction) + "\" is not valid.")
         }
 
-        // A terminal parameter marks a record route (/boards/{id}); a
-        // cross-reference ends in the relationship's name
-        // (/posts/{id}/author). Failing that, the shallower path wins. The
-        // same rule runs at generation time, in helpers/opShape.ts — both
-        // sides must move together.
-        def partsLen(p: JMap[String, Object]): Int =
-          Struct.getprop(p, "parts") match {
-            case parts: JList[_] => parts.size()
-            case _ => 0
-          }
-        def terminalParam(p: JMap[String, Object]): Boolean =
-          Struct.getprop(p, "parts") match {
-            case parts: JList[_] if parts.size() > 0 =>
-              parts.get(parts.size() - 1) match {
-                case s: String => s.startsWith("{")
-                case _ => false
-              }
-            case _ => false
-          }
+        // A call without an action falls back to a point without one, as
+        // generation does, and only to a route the call can fill.
+        val all = (0 until op.points.size()).map(op.points.get(_))
+        val plain = all.filter(cand =>
+          Struct.getprop(Helpers.toMapAny(Struct.getprop(cand, "select")), "$action", null) == null)
+        if (plain.isEmpty) {
+          throw ctx.makeError("point_action_required",
+            "Operation \"" + op.name + "\" has only action endpoints; pass $action to choose one.")
+        }
 
-        point = op.points.get(0)
-        var j = 0
-        while (j < op.points.size()) {
-          val cand = op.points.get(j)
-          val candTerm = terminalParam(cand)
-          val bestTerm = terminalParam(point)
-          if (candTerm != bestTerm) {
-            if (candTerm) point = cand
-          } else if (partsLen(cand) < partsLen(point)) {
-            point = cand
-          }
-          j += 1
+        val fillable = plain.filter(cand => unfilled(ctx, cand).isEmpty)
+
+        if (fillable.isEmpty) {
+          throw ctx.makeError("point_no_match",
+            "Operation \"" + op.name + "\" has no endpoint whose path parameters are all given (missing: " +
+              unfilled(ctx, ownPoint(plain)).mkString(", ") + ").")
         }
+
+        point = ownPoint(fillable)
       }
 
       if (reqselector != null) {
@@ -202,6 +247,9 @@ object MakePoint {
 
 object MakeOptions {
 
+  // A {name} placeholder in a templated server URL (an OpenAPI server variable).
+  private val SERVER_VAR = "\\{([A-Za-z0-9_]+)\\}".r
+
   /**
    * Replaces one utility member from `options.utility`, matching the ts
    * reference: a key naming a real member REPLACES it, and any other key is
@@ -373,6 +421,38 @@ object MakeOptions {
       else { val sm = new LinkedHashMap[String, Object](); sm.put("fetch", sysFetch); opts.put("system", sm) }
     }
 
+    // A templated base URL takes each {name} from options.server. An empty
+    // value cannot make a working URL, so it fails construction, except in
+    // test mode, where it becomes test-<name>.
+    opts.get("base") match {
+      case base: String if base.contains("{") =>
+        val testmode =
+          java.lang.Boolean.TRUE == Struct.getpath(opts, java.util.List.of("test", "active")) ||
+            java.lang.Boolean.TRUE == Struct.getpath(opts, java.util.List.of("feature", "test", "active"))
+        val server = Helpers.toMapAny(opts.get("server"))
+        val sdkname = Struct.getpath(config, java.util.List.of("main", "name")) match {
+          case s: String if s.nonEmpty => s
+          case _ => "SDK"
+        }
+        val resolved = SERVER_VAR.replaceAllIn(base, (m: scala.util.matching.Regex.Match) => {
+          val name = m.group(1)
+          val value = (if (server == null) null else server.get(name)) match {
+            case s: String => s
+            case _ => ""
+          }
+          val filled =
+            if ("" != value) value
+            else if (testmode) "test-" + name
+            else throw new SdkError("server_var_required",
+              sdkname + ": the server variable '" + name + "' is required: the API base URL is '" +
+                base + "' - pass options.put(\"server\", java.util.Map.of(\"" + name +
+                "\", \"...\")) in the SDK options", ctx)
+          scala.util.matching.Regex.quoteReplacement(filled)
+        })
+        opts.put("base", resolved)
+      case _ =>
+    }
+
     // Resolve the feature add-order: an explicit list order (above) wins;
     // otherwise order the map test-first, then the remaining names sorted, so
     // the outcome is deterministic and `test` is always the base transport.
@@ -403,19 +483,28 @@ object MakeOptions {
 
   // A feature's name is not a field name: a feature called `secrets` does not
   // make every one of its options a secret. Entity blocks (entity settings,
-  // seeded records) hold no credential.
+  // seeded records) hold no credential, and nor do rbac's rules, keyed by
+  // entity and operation names.
   private def addSensitiveOptions(cfg: CleanConfig, m: JMap[String, Object], keys: String*): Unit = {
     val top = omit(m, (keys :+ "feature" :+ "entity")*)
-    if (top.containsKey("test")) top.put("test", noEntity(top.get("test")))
+    if (top.containsKey("test")) top.put("test", plain(top.get("test"), null))
     Clean.addSensitiveWith(cfg, top)
     m.get("feature") match {
-      case fm: JMap[_, _] => fm.values().forEach(v => Clean.addSensitiveWith(cfg, noEntity(v.asInstanceOf[Object])))
-      case fl: JList[_] => fl.forEach(v => Clean.addSensitiveWith(cfg, noEntity(v.asInstanceOf[Object])))
+      case fm: JMap[_, _] =>
+        fm.asInstanceOf[JMap[Object, Object]].forEach((k, v) => Clean.addSensitiveWith(cfg, plain(v, String.valueOf(k))))
+      case fl: JList[_] => fl.forEach { v =>
+        val name = v match {
+          case vm: JMap[_, _] => vm.get("name") match { case s: String => s; case _ => null }
+          case _ => null
+        }
+        Clean.addSensitiveWith(cfg, plain(v.asInstanceOf[Object], name))
+      }
       case other => Clean.addSensitiveWith(cfg, other)
     }
   }
 
-  private def noEntity(block: Object): Object = block match {
+  private def plain(block: Object, name: String): Object = block match {
+    case bm: JMap[_, _] if "rbac" == name => omit(bm.asInstanceOf[JMap[String, Object]], "entity", "rules")
     case bm: JMap[_, _] => omit(bm.asInstanceOf[JMap[String, Object]], "entity")
     case other => other
   }
@@ -445,10 +534,7 @@ object MakeFetchDef {
     fetchdef.put("headers", spec.headers)
 
     if (spec.body != null) {
-      spec.body match {
-        case _: JMap[_, _] => fetchdef.put("body", Struct.jsonify(spec.body))
-        case _ => fetchdef.put("body", spec.body)
-      }
+      fetchdef.put("body", Media.requestBody(ctx.point, spec.body))
     }
 
     fetchdef
@@ -603,6 +689,10 @@ object MakeUrl {
 
     val resmatch = new LinkedHashMap[String, Object]()
 
+    // Sent with the request, never recorded as the entity's match.
+    val authquery: JList[String] =
+      if (spec.authquery == null) new java.util.ArrayList[String]() else spec.authquery
+
     val pit = Struct.items(spec.params).iterator()
     while (pit.hasNext) {
       val item = pit.next()
@@ -615,6 +705,14 @@ object MakeUrl {
       }
     }
 
+    // A placeholder left in the route would send the request to the wrong route.
+    // The base's own placeholders are server variables, resolved with the options.
+    val base = if (null == spec.base) "" else spec.base.replaceAll("/+$", "")
+    val unfilled = "\\{[^{}/]+\\}".r.findAllIn(url.stripPrefix(base)).toList
+    if (unfilled.nonEmpty) {
+      throw ctx.makeError("url_param_missing", "URL path has no value for " + unfilled.mkString(", ") + ".")
+    }
+
     var qsep = "?"
     val qit = Struct.items(spec.query).iterator()
     while (qit.hasNext) {
@@ -624,7 +722,7 @@ object MakeUrl {
       if (v != null) {
         url += qsep + Struct.escurl(key) + "=" + Struct.escurl(Struct.stringify(v))
         qsep = "&"
-        resmatch.put(key, v)
+        if (!authquery.contains(key)) resmatch.put(key, v)
       }
     }
 

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

@@ -35,8 +35,9 @@ object MakeSpec {
 
     ctx.spec.method = utility.prepareMethod(ctx)
 
-    val allowMethod = Struct.getpath(options, java.util.List.of("allow", "method")) match { case s: String => s; case _ => "" }
-    if (!allowMethod.contains(ctx.spec.method)) {
+    val allowMethodRaw = Struct.getpath(options, java.util.List.of("allow", "method"))
+    val allowMethod = allowMethodRaw match { case s: String => s; case _ => "" }
+    if (!Helpers.allowed(allowMethodRaw, ctx.spec.method)) {
       throw ctx.makeError("spec_method_allow",
         "Method \"" + ctx.spec.method + "\" not allowed by SDK option allow.method value: \"" + allowMethod + "\"")
     }
@@ -69,7 +70,24 @@ object MakeSpec {
 
     if (ctx.ctrl.explain != null) ctx.ctrl.explain.put("spec", ctx.spec)
 
+    // Whatever prepareAuth sets in the query, under whichever name, is the
+    // credential; a key it leaves as it was is the caller's.
+    val query = new LinkedHashMap[String, Object]()
+    if (ctx.spec.query != null) query.putAll(ctx.spec.query)
+
     val spec = utility.prepareAuth(ctx)
+    val authquery = new java.util.ArrayList[String]()
+    if (spec.query != null) {
+      val qit = spec.query.entrySet().iterator()
+      while (qit.hasNext) {
+        val entry = qit.next()
+        if (!query.containsKey(entry.getKey) ||
+          !java.util.Objects.equals(query.get(entry.getKey), entry.getValue)) {
+          authquery.add(entry.getKey)
+        }
+      }
+    }
+    spec.authquery = authquery
     ctx.spec = spec
     spec
   }

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

@@ -0,0 +1,96 @@
+package SCALAPACKAGE.utility
+
+import java.util.{ArrayList, List => JList, Locale, Map => JMap}
+import SCALAPACKAGE.utility.struct.Struct
+
+// The media types a point declares: `response` (the model's `rs`) for the
+// Accept header, and `body` (the model's `rb`) for the request body.
+object Media {
+
+  // The data key holding a raw request body. Like `$action`, it can never be
+  // a declared argument name.
+  val RawBody: String = "$body"
+
+  def isJsonMedia(media: Object): Boolean = {
+    val m = (media match { case s: String => s; case _ => "" })
+      .split(";", 2)(0).trim.toLowerCase(Locale.ROOT)
+    m == "application/json" || m == "text/json" || m.endsWith("+json")
+  }
+
+  // The declared JSON type alone, else every declared type in the model's
+  // order; null when no success response declares a body.
+  def acceptOf(point: Object): String = {
+    val res = Struct.getprop(point, "response")
+    Struct.getprop(res, "media") match {
+      case media: String if media.nonEmpty =>
+        if ("json" == Struct.getprop(res, "kind")) media
+        else {
+          val types = new ArrayList[String]()
+          types.add(media)
+          Struct.getprop(res, "alternatives") match {
+            case alts: JList[_] =>
+              alts.forEach { alt =>
+                Struct.getprop(alt, "media") match {
+                  case m: String if m.nonEmpty => types.add(m)
+                  case _ =>
+                }
+              }
+            case _ =>
+          }
+          String.join(", ", types)
+        }
+      case _ => null
+    }
+  }
+
+  def isRawRequest(point: Object): Boolean =
+    "raw" == Struct.getprop(Struct.getprop(point, "body"), "kind")
+
+  def isJsonRequest(point: Object): Boolean =
+    "json" == Struct.getprop(Struct.getprop(point, "body"), "kind")
+
+  // Bytes or a stream go as given. A map or a list is JSON, and so is a scalar
+  // on a point that declares a JSON body.
+  def requestBody(point: Object, body: Object): Object = body match {
+    case _: Array[Byte] | _: java.io.InputStream => body
+    case _ if Struct.isnode(body) || isJsonRequest(point) => Struct.jsonify(body)
+    case _ => body
+  }
+
+  private def hasHeader(headers: JMap[String, Object], name: String): Boolean =
+    headers.keySet().stream().anyMatch(k => k != null && k.toLowerCase(Locale.ROOT) == name)
+
+  // A caller's accept wins. A declared request type replaces each JSON
+  // content-type, the SDK default, and leaves any other the caller set.
+  def headers(point: Object, headers: JMap[String, Object]): JMap[String, Object] = {
+    val accept = acceptOf(point)
+    if (accept != null && !hasHeader(headers, "accept")) {
+      headers.put("accept", accept)
+    }
+
+    val body = Struct.getprop(point, "body")
+    val kind = Struct.getprop(body, "kind")
+    Struct.getprop(body, "media") match {
+      case media: String if media.nonEmpty && ("raw" == kind || "json" == kind) =>
+        headers.entrySet().removeIf(e => e.getKey != null &&
+          e.getKey.toLowerCase(Locale.ROOT) == "content-type" && isJsonMedia(e.getValue))
+        if (!hasHeader(headers, "content-type")) {
+          headers.put("content-type", media)
+        }
+      case _ =>
+    }
+
+    headers
+  }
+
+  // Bytes, an InputStream or a String, sent as they are. An InputStream can be
+  // read once, so it is read here, before the first attempt, and a retry sends
+  // the same bytes again.
+  def rawBody(reqdata: JMap[String, Object]): Object = {
+    val body = if (reqdata == null) null else reqdata.get(RawBody)
+    body match {
+      case stream: java.io.InputStream => stream.readAllBytes()
+      case other => other
+    }
+  }
+}

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

@@ -383,39 +383,72 @@ object Done {
 
 object Param {
   def param(ctx: Context, paramdef: Object): Object = {
-    val point = ctx.point
-    val spec = ctx.spec
-    val matchData = ctx.matchData
-    val reqmatch = ctx.reqmatch
-    val data = ctx.data
-    val reqdata = ctx.reqdata
-
     val pt = Struct.typify(paramdef)
 
     val key: String =
       if (0 < (Struct.T_string & pt)) paramdef match { case s: String => s; case _ => "" }
       else Struct.getprop(paramdef, "name") match { case s: String => s; case _ => "" }
 
-    var akey = ""
-    if (point != null) {
-      val alias = Helpers.toMapAny(Struct.getprop(point, "alias"))
-      if (alias != null) {
-        Struct.getprop(alias, key) match { case ak: String => akey = ak; case _ => }
-      }
+    val akey = alias(ctx.point, key)
+    if (ctx.spec != null && "" != akey &&
+      Struct.getprop(ctx.reqmatch, key, null) == null && Struct.getprop(ctx.matchData, key, null) == null) {
+      ctx.spec.alias.put(akey, key)
     }
 
-    var v = Struct.getprop(reqmatch, key, null)
-    if (v == null) v = Struct.getprop(matchData, key, null)
-    if (v == null && "" != akey) {
-      if (spec != null) spec.alias.put(akey, key)
-      v = Struct.getprop(reqmatch, akey, null)
-    }
-    if (v == null) v = Struct.getprop(reqdata, key, null)
-    if (v == null) v = Struct.getprop(data, key, null)
+    value(ctx, ctx.point, key)
+  }
+
+  // The name a point gives a parameter in the call, if it renames it.
+  private def alias(point: Object, key: String): String = {
+    if (point == null) return ""
+    val aliasMap = Helpers.toMapAny(Struct.getprop(point, "alias"))
+    if (aliasMap == null) return ""
+    Struct.getprop(aliasMap, key) match { case ak: String => ak; case _ => "" }
+  }
+
+  // The value the call or its entity gives a point's parameter, under its
+  // name or the point's alias for it.
+  def value(ctx: Context, point: Object, key: String): Object = {
+    val akey = alias(point, key)
+
+    var v = Struct.getprop(ctx.reqmatch, key, null)
+    if (v == null) v = Struct.getprop(ctx.matchData, key, null)
+    if (v == null && "" != akey) v = Struct.getprop(ctx.reqmatch, akey, null)
+    if (v == null) v = Struct.getprop(ctx.reqdata, key, null)
+    if (v == null) v = Struct.getprop(ctx.data, key, null)
     if (v == null && "" != akey) {
-      v = Struct.getprop(reqdata, akey, null)
-      if (v == null) v = Struct.getprop(data, akey, null)
+      v = Struct.getprop(ctx.reqdata, akey, null)
+      if (v == null) v = Struct.getprop(ctx.data, akey, null)
     }
     v
   }
+
+  // The arguments a point declares in one location, query or header, each as
+  // (name, wire, value): the name it travels under and the value this call
+  // passes in its match or else its data. Unlike a path parameter, the
+  // entity's stored match and data never supply one.
+  def callArgs(ctx: Context, kind: String): Seq[(String, String, Object)] = {
+    if (ctx.point == null) return Seq.empty
+    Struct.getpath(ctx.point, java.util.List.of("args", kind)) match {
+      case l: JList[_] =>
+        val out = scala.collection.mutable.ArrayBuffer[(String, String, Object)]()
+        val it = l.iterator()
+        while (it.hasNext) {
+          val ad = it.next()
+          Struct.getprop(ad, "name") match {
+            case name: String if name.nonEmpty =>
+              val wire = Struct.getprop(ad, "orig") match {
+                case o: String if o.nonEmpty => o
+                case _ => name
+              }
+              var v: Object = if (ctx.reqmatch == null) null else Struct.getprop(ctx.reqmatch, name, null)
+              if (v == null && ctx.reqdata != null) v = Struct.getprop(ctx.reqdata, name, null)
+              out += ((name, wire, v))
+            case _ =>
+          }
+        }
+        out.toSeq
+      case _ => Seq.empty
+    }
+  }
 }

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

@@ -18,7 +18,7 @@ object PrepareMethod {
   // exposes `update` as POST or PATCH, not the PUT the op name implies.
   // Only fall back to the op-name convention when the point has no method.
   def prepareMethod(ctx: Context): String = Struct.getprop(ctx.point, "method") match {
-    case s: String if s.nonEmpty => s.toUpperCase
+    case s: String if s.nonEmpty => s.toUpperCase(java.util.Locale.ROOT)
     case _ => ctx.op.name match {
       case "create" => "POST"
       case "update" => "PUT"
@@ -80,12 +80,18 @@ object PrepareQuery {
           }
         case _ =>
       }
-      // A header parameter travels in the headers, which prepareHeaders fills.
-      Struct.getpath(point, java.util.List.of("args", "header")) match {
+      // A header or cookie name leaves the query unless a query parameter shares it: then both are sent.
+      val declared = new ArrayList[Object]()
+      Struct.getpath(point, java.util.List.of("args", "query")) match {
+        case l: JList[_] => val dit = l.iterator(); while (dit.hasNext) declared.add(Struct.getprop(dit.next(), "name"))
+        case _ =>
+      }
+      for (located <- Seq(Struct.getpath(point, java.util.List.of("args", "header")),
+        Struct.getpath(point, java.util.List.of("args", "cookie")))) located match {
         case l: JList[_] =>
           val hit = l.iterator()
           while (hit.hasNext) {
-            Struct.getprop(hit.next(), "name") match { case s: String => params.add(s); case _ => }
+            Struct.getprop(hit.next(), "name") match { case s: String if !declared.contains(s) => params.add(s); case _ => }
           }
         case _ =>
       }
@@ -117,6 +123,11 @@ object PrepareQuery {
       val v = item.get(1)
       if (v != null && "$action" != key && !containsStr(params, key)) out.put(wire.getOrDefault(key, key), v)
     }
+
+    // A create or update passes its query arguments in its data.
+    for ((name, orig, v) <- Param.callArgs(ctx, "query") if v != null && !containsStr(params, name)) {
+      out.put(orig, v)
+    }
     out
   }
 
@@ -134,44 +145,86 @@ object PrepareHeaders {
     val options = ctx.client.optionsMap()
     val headers = Struct.getprop(options, "headers")
     val cloned = if (headers == null) null else Helpers.toMapAny(Struct.clone(headers))
-    val out: JMap[String, Object] = if (cloned != null) cloned else new LinkedHashMap[String, Object]()
+    val out: JMap[String, Object] = Media.headers(ctx.point,
+      if (cloned != null) cloned else new LinkedHashMap[String, Object]())
+
+    // A header argument replaces a default of the same name, whatever its case.
+    for ((_, wire, v) <- Param.callArgs(ctx, "header") if v != null) {
+      val key = wire.toLowerCase(java.util.Locale.ROOT)
+      out.keySet().removeIf(k => k != null && k.toLowerCase(java.util.Locale.ROOT) == key)
+      out.put(key, Struct.stringify(v))
+    }
 
-    // A header parameter travels as a header, under the name the definition
-    // gives it, and only from this call's own arguments. It replaces a default
-    // of the same name, whatever its case.
-    if (ctx.point != null) {
-      Struct.getpath(ctx.point, java.util.List.of("args", "header")) match {
-        case l: JList[_] =>
-          val hit = l.iterator()
-          while (hit.hasNext) {
-            val hd = hit.next()
-            Struct.getprop(hd, "name") match {
-              case name: String if name.nonEmpty =>
-                val wire = Struct.getprop(hd, "orig") match {
-                  case o: String if o.nonEmpty => o
-                  case _ => name
-                }
-                var v: Object = if (ctx.reqmatch == null) null else Struct.getprop(ctx.reqmatch, name, null)
-                if (v == null && ctx.reqdata != null) v = Struct.getprop(ctx.reqdata, name, null)
-                if (v != null) {
-                  val key = wire.toLowerCase(java.util.Locale.ROOT)
-                  out.keySet().removeIf(k => k != null && k.toLowerCase(java.util.Locale.ROOT) == key)
-                  out.put(key, Struct.stringify(v))
-                }
-              case _ =>
-            }
+    // A cookie argument travels in the cookie header, form serialized and
+    // percent-encoded, replacing a cookie of the same name among those the
+    // caller's headers already send.
+    val sent = Param.callArgs(ctx, "cookie").filter { case (_, _, v) => v != null }
+    if (sent.nonEmpty) {
+      val names = sent.flatMap { case (_, wire, v) =>
+        v match {
+          case m: JMap[_, _] => Struct.keysof(m).toArray(Array.empty[String]).toSeq.map(k => Struct.escurl(k))
+          case _ => Seq(wire)
+        }
+      }
+      val kept = scala.collection.mutable.ArrayBuffer[String]()
+      val it = out.entrySet().iterator()
+      while (it.hasNext) {
+        val e = it.next()
+        if (e.getKey != null && "cookie" == e.getKey.toLowerCase(java.util.Locale.ROOT)) {
+          e.getValue match {
+            case s: String => kept ++= cookieKeep(s, names)
+            case _ =>
           }
-        case _ =>
+          it.remove()
+        }
       }
+      sent.foreach { case (_, wire, v) =>
+        val pair = cookiePair(wire, v)
+        if (pair.nonEmpty) kept += pair
+      }
+      if (kept.nonEmpty) out.put("cookie", kept.mkString("; "))
     }
 
     out
   }
+
+  // The caller's cookie pieces with the named cookies removed: a cookie is one
+  // ;-delimited piece, whatever its value holds.
+  def cookieKeep(header: String, names: Seq[String]): scala.collection.mutable.ArrayBuffer[String] = {
+    val kept = scala.collection.mutable.ArrayBuffer[String]()
+    header.split(";").foreach { piece =>
+      val cookie = piece.trim
+      if (cookie.nonEmpty && !names.contains(cookie.split("=", 2)(0).trim)) kept += cookie
+    }
+    kept
+  }
+
+  // The form style of a cookie parameter: a list repeats the name, a map sends
+  // its own keys, and every value is percent-encoded.
+  private def cookiePair(wire: String, v: Object): String = {
+    def esc(x: Object): String = Struct.escurl(Struct.stringify(x))
+    val pairs = scala.collection.mutable.ArrayBuffer[String]()
+    v match {
+      case l: JList[_] =>
+        val it = l.iterator()
+        while (it.hasNext) pairs += wire + "=" + esc(it.next().asInstanceOf[Object])
+      case m: JMap[_, _] =>
+        val keys = Struct.keysof(m).iterator()
+        while (keys.hasNext) {
+          val k = keys.next()
+          pairs += Struct.escurl(k) + "=" + esc(Struct.getprop(m, k))
+        }
+      case _ => pairs += wire + "=" + esc(v)
+    }
+    pairs.mkString("; ")
+  }
 }
 
 object PrepareBody {
   def prepareBody(ctx: Context): Object =
-    if ("data" == ctx.op.input) ctx.utility.transformRequest(ctx) else null
+    if ("data" != ctx.op.input) null
+    else if (Media.isRawRequest(ctx.point)) Media.rawBody(ctx.reqdata)
+    else ctx.utility.transformRequest(ctx)
 }
 
 // NO `object PrepareAuth` HERE, and its absence is the point.

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

@@ -38,6 +38,11 @@ object ResultBody {
       if (response != null && response.jsonFunc != null && response.body != null) {
         result.body = response.jsonFunc.get()
       }
+      if (response != null && response.unreadable) {
+        val sent = if (ctx.spec == null) null else ctx.spec.headers
+        result.err = Response.unreadableBody(ctx, result.status, result.headers, response.body,
+          sent, result.err)
+      }
     }
 
     result