@voxgig/sdkgen 4.33.0 → 4.34.1

package/project/.sdk/tm/go/utility/prepare_headers.go

@@ -1,6 +1,7 @@
 package utility
 
 import (
+	"reflect"
 	"strings"
 
 	vs "github.com/voxgig/struct"
@@ -17,35 +18,120 @@ func prepareHeadersUtil(ctx *core.Context) map[string]any {
 			out = om
 		}
 	}
+	out = mediaHeaders(ctx.Point, out)
 
-	// 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 hl, ok := vs.GetPath(ctx.Point, []any{"args", "header"}).([]any); ok {
-		for _, hd := range hl {
-			name, _ := vs.GetProp(hd, "name").(string)
-			orig, _ := vs.GetProp(hd, "orig").(string)
-			if "" == name {
-				continue
+	// A header argument replaces a default of the same name, whatever its case.
+	for _, arg := range callArgs(ctx, "header") {
+		if arg.val != nil {
+			wire := strings.ToLower(arg.wire)
+			for key := range out {
+				if strings.ToLower(key) == wire {
+					delete(out, key)
+				}
+			}
+			out[wire] = vs.Stringify(arg.val)
+		}
+	}
+
+	// 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.
+	sent := []callArg{}
+	for _, arg := range callArgs(ctx, "cookie") {
+		if arg.val != nil {
+			sent = append(sent, arg)
+		}
+	}
+	if 0 < len(sent) {
+		names := map[string]bool{}
+		for _, arg := range sent {
+			for _, name := range cookieNames(arg) {
+				names[name] = true
 			}
-			if "" == orig {
-				orig = name
+		}
+		kept := []string{}
+		for key, val := range out {
+			if strings.ToLower(key) != "cookie" {
+				continue
 			}
-			val := vs.GetProp(ctx.Reqmatch, name)
-			if val == nil {
-				val = vs.GetProp(ctx.Reqdata, name)
+			if given, ok := val.(string); ok {
+				kept = append(kept, cookieKeep(given, names)...)
 			}
-			if val != nil {
-				wire := strings.ToLower(orig)
-				for key := range out {
-					if strings.ToLower(key) == wire {
-						delete(out, key)
-					}
-				}
-				out[wire] = vs.Stringify(val)
+			delete(out, key)
+		}
+		for _, arg := range sent {
+			if pair := cookiePair(arg.wire, arg.val); "" != pair {
+				kept = append(kept, pair)
 			}
 		}
+		if 0 < len(kept) {
+			out["cookie"] = strings.Join(kept, "; ")
+		}
 	}
 
 	return out
 }
+
+// The cookie names an argument sends: a map's own keys as the pair sends
+// them, percent-encoded, else its wire name.
+func cookieNames(arg callArg) []string {
+	if m, ok := cookieMap(arg.val); ok {
+		names := []string{}
+		for _, key := range vs.KeysOf(m) {
+			names = append(names, vs.EscUrl(key))
+		}
+		return names
+	}
+	return []string{arg.wire}
+}
+
+// A map argument as the port reads one, a typed map with string keys included:
+// IsList takes any slice, while IsMap takes map[string]any alone.
+func cookieMap(val any) (map[string]any, bool) {
+	if vs.IsMap(val) {
+		return val.(map[string]any), true
+	}
+	rv := reflect.ValueOf(val)
+	if !rv.IsValid() || rv.Kind() != reflect.Map || rv.Type().Key().Kind() != reflect.String {
+		return nil, false
+	}
+	out := map[string]any{}
+	for _, key := range rv.MapKeys() {
+		out[key.String()] = rv.MapIndex(key).Interface()
+	}
+	return out, true
+}
+
+// The form style of a cookie parameter: a list repeats the name, a map sends
+// its own keys, and every value is percent-encoded.
+func cookiePair(wire string, val any) string {
+	esc := func(v any) string { return vs.EscUrl(vs.Stringify(v)) }
+	pairs := []string{}
+	m, ismap := cookieMap(val)
+	switch {
+	case vs.IsList(val):
+		for _, item := range vs.Items(val) {
+			pairs = append(pairs, wire+"="+esc(item[1]))
+		}
+	case ismap:
+		for _, key := range vs.KeysOf(m) {
+			pairs = append(pairs, vs.EscUrl(key)+"="+esc(vs.GetProp(m, key)))
+		}
+	default:
+		pairs = append(pairs, wire+"="+esc(val))
+	}
+	return strings.Join(pairs, "; ")
+}
+
+// The caller's cookie pieces with the named cookies removed: a cookie is one
+// ;-delimited piece, whatever its value holds.
+func cookieKeep(header string, names map[string]bool) []string {
+	kept := []string{}
+	for _, piece := range strings.Split(header, ";") {
+		cookie := strings.TrimSpace(piece)
+		if "" != cookie && !names[strings.TrimSpace(strings.SplitN(cookie, "=", 2)[0])] {
+			kept = append(kept, cookie)
+		}
+	}
+	return kept
+}

package/project/.sdk/tm/go/utility/prepare_query.go

@@ -37,11 +37,27 @@ func prepareQueryUtil(ctx *core.Context) map[string]any {
 		}
 	}
 
-	// A header parameter travels in the headers, which prepareHeaders fills.
+	// A header or cookie parameter travels in the headers, which prepareHeaders
+	// fills, unless a query parameter shares its name: then both are sent.
 	if point != nil {
+		declared := map[string]bool{}
+		if ql, ok := vs.GetPath(point, []any{"args", "query"}).([]any); ok {
+			for _, qd := range ql {
+				if name, ok := vs.GetProp(qd, "name").(string); ok {
+					declared[name] = true
+				}
+			}
+		}
 		if hl, ok := vs.GetPath(point, []any{"args", "header"}).([]any); ok {
 			for _, hd := range hl {
-				if name, ok := vs.GetProp(hd, "name").(string); ok {
+				if name, ok := vs.GetProp(hd, "name").(string); ok && !declared[name] {
+					params = append(params, name)
+				}
+			}
+		}
+		if cl, ok := vs.GetPath(point, []any{"args", "cookie"}).([]any); ok {
+			for _, cd := range cl {
+				if name, ok := vs.GetProp(cd, "name").(string); ok && !declared[name] {
 					params = append(params, name)
 				}
 			}
@@ -75,6 +91,13 @@ func prepareQueryUtil(ctx *core.Context) map[string]any {
 		}
 	}
 
+	// A create or update passes its query arguments in its data.
+	for _, arg := range callArgs(ctx, "query") {
+		if arg.val != nil && !containsStr(params, arg.name) {
+			out[arg.wire] = arg.val
+		}
+	}
+
 	return out
 }
 

package/project/.sdk/tm/go/utility/result_body.go

@@ -11,6 +11,14 @@ func resultBodyUtil(ctx *core.Context) *core.Result {
 			json := response.JsonFunc()
 			result.Body = json
 		}
+		if response != nil && response.Unreadable {
+			var sent any
+			if ctx.Spec != nil {
+				sent = ctx.Spec.Headers
+			}
+			result.Err = core.UnreadableBody(ctx, result.Status, result.Headers, response.Body,
+				sent, result.Err)
+		}
 	}
 
 	return result

package/project/.sdk/tm/go/utility/transform_request.go

@@ -14,7 +14,7 @@ func transformRequestUtil(ctx *core.Context) any {
 		spec.Step = "reqform"
 	}
 
-	data := omitKeys(ctx.Reqdata, headerArgNames(point))
+	data := omitKeys(ctx.Reqdata, routedArgNames(ctx))
 
 	transform := core.ToMapAny(vs.GetProp(point, "transform"))
 	if transform == nil {
@@ -47,20 +47,31 @@ func stripAction(reqdata any) any {
 	return omitKeys(reqdata, []string{"$action"})
 }
 
-// A header argument travels as a header, which prepareHeadersUtil sends, so
-// the body is built from the request data without it.
-func headerArgNames(point any) []string {
+// A header, cookie or query argument travels where prepareHeadersUtil or
+// prepareQueryUtil sends it, so the body is built from the request data
+// without it, unless the entity declares it as a field too.
+func routedArgNames(ctx *core.Context) []string {
 	names := []string{}
-	if hl, ok := vs.GetPath(point, []any{"args", "header"}).([]any); ok {
-		for _, hd := range hl {
-			if name, _ := vs.GetProp(hd, "name").(string); "" != name {
-				names = append(names, name)
-			}
+	for _, arg := range append(append(callArgs(ctx, "header"), callArgs(ctx, "cookie")...), callArgs(ctx, "query")...) {
+		if !fieldArg(ctx, arg.name) {
+			names = append(names, arg.name)
 		}
 	}
 	return names
 }
 
+func fieldArg(ctx *core.Context, name string) bool {
+	for _, kind := range []string{"header", "cookie", "query"} {
+		al, _ := vs.GetPath(ctx.Point, []any{"args", kind}).([]any)
+		for _, ad := range al {
+			if n, _ := vs.GetProp(ad, "name").(string); n == name && true == vs.GetProp(ad, "field") {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func omitKeys(reqdata any, names []string) any {
 	src, ok := reqdata.(map[string]any)
 	if !ok {

package/project/.sdk/tm/java/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -237,7 +237,7 @@ public class Context {
         List.of("entity", entname, "op", opname));
 
     String input = "match";
-    if ("update".equals(opname) || "create".equals(opname)) {
+    if ("update".equals(opname) || "create".equals(opname) || "patch".equals(opname)) {
       input = "data";
     }
 

package/project/.sdk/tm/java/core/Helpers.java

@@ -17,6 +17,19 @@ public final class Helpers {
         "operation '" + opname + "' not supported by entity '" + entityname + "'", null);
   }
 
+  // Whether a comma-separated allow option names the item: whole names, any case.
+  public static boolean allowed(Object names, String item) {
+    if (!(names instanceof String) || null == item || item.isEmpty()) {
+      return false;
+    }
+    for (String name : ((String) names).split(",", -1)) {
+      if (name.trim().equalsIgnoreCase(item)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   public static Map<String, Object> toMapAny(Object v) {
     if (v == null) {
       return null;

package/project/.sdk/tm/java/core/Response.java

@@ -14,6 +14,10 @@ public class Response {
   public Supplier<Object> jsonFunc;
   public Object body;
   public RuntimeException err;
+  // Set by a transport that could not read a non-blank body as JSON.
+  public boolean unreadable;
+
+  private static final int PREVIEW_LENGTH = 160;
 
   public Response(Map<String, Object> resmap) {
     Object s = Struct.getprop(resmap, "status");
@@ -39,6 +43,63 @@ public class Response {
     if (e instanceof RuntimeException) {
       this.err = (RuntimeException) e;
     }
+
+    this.unreadable = Boolean.TRUE.equals(Struct.getprop(resmap, "unreadable"));
+  }
+
+  /**
+   * A body that is not JSON. An HTTP failure keeps its own error, with the
+   * response described; otherwise the code tells a wrong content type from
+   * malformed JSON.
+   */
+  public static RuntimeException unreadableBody(Context ctx, int status, Object headers,
+      Object text, Object sent, RuntimeException failed) {
+    String type = headerValue(headers, "content-type");
+    Object cleaned = ctx.utility.clean.apply(ctx, headerValue(sent, "user-agent"));
+    String agent = cleaned == null ? "" : String.valueOf(cleaned);
+    if (agent.isEmpty()) {
+      agent = "transport default";
+    }
+    String detail = "HTTP " + status + ", content-type " + (type.isEmpty() ? "none" : type)
+        + ", user-agent " + agent + (text == null ? "" : ", body: " + preview(ctx, text));
+
+    if (failed != null) {
+      if (failed instanceof SdkError) {
+        ((SdkError) failed).msg += " (" + detail + ")";
+        return failed;
+      }
+      return new RuntimeException(failed.getMessage() + " (" + detail + ")", failed);
+    }
+
+    if (type.isEmpty() || type.toLowerCase().contains("json")) {
+      return ctx.makeError("response_json_invalid",
+          "response: body is not valid JSON (" + detail + ")");
+    }
+    return ctx.makeError("response_content_type",
+        "response: expected JSON, got " + type + " (" + detail + ")");
+  }
+
+  private static String headerValue(Object headers, String name) {
+    if (!(headers instanceof Map)) {
+      return "";
+    }
+    for (Map.Entry<?, ?> entry : ((Map<?, ?>) headers).entrySet()) {
+      if (name.equalsIgnoreCase(String.valueOf(entry.getKey()))) {
+        return String.valueOf(entry.getValue());
+      }
+    }
+    return "";
+  }
+
+  // Cleaned whole: a secret the bound would split could leave its prefix.
+  private static String preview(Context ctx, Object text) {
+    Object cleaned = ctx.utility.clean.apply(ctx,
+        String.valueOf(text).replaceAll("\\s+", " ").trim());
+    String flat = cleaned == null ? "" : String.valueOf(cleaned);
+    if (flat.codePointCount(0, flat.length()) <= PREVIEW_LENGTH) {
+      return flat;
+    }
+    return flat.substring(0, flat.offsetByCodePoints(0, PREVIEW_LENGTH)) + "...";
   }
 
   @SuppressWarnings("unchecked")

package/project/.sdk/tm/java/core/SdkClient.java

@@ -138,6 +138,14 @@ public abstract class SdkClient {
     if ("".equals(method)) {
       method = "GET";
     }
+    method = method.toUpperCase(java.util.Locale.ROOT);
+
+    Object allowMethod = Struct.getpath(options, List.of("allow", "method"));
+    if (!Helpers.allowed(allowMethod, method)) {
+      throw ctx.makeError("spec_method_allow",
+          "Method \"" + method + "\" not allowed by SDK option allow.method value: \""
+              + (allowMethod instanceof String ? allowMethod : "") + "\"");
+    }
 
     Map<String, Object> params = Helpers.toMapAny(Struct.getprop(fetchargs, "params"));
     if (params == null) {
@@ -193,8 +201,7 @@ public abstract class SdkClient {
 
   /** Is this raw-access op permitted by the SDK's allow.op option? */
   private boolean opAllowed(String op) {
-    Object allow = Struct.getpath(this.options, List.of("allow", "op"));
-    return allow instanceof String && ((String) allow).contains(op);
+    return Helpers.allowed(Struct.getpath(this.options, List.of("allow", "op")), op);
   }
 
   private Map<String, Object> opDenied(String op) {
@@ -337,18 +344,29 @@ public abstract class SdkClient {
       boolean noBody = status == 204 || status == 304 || "0".equals(contentLength);
 
       Object jsonData = null;
+      RuntimeException bodyErr = null;
       if (!noBody) {
         Object jf = Struct.getprop(fm, "json");
         if (jf instanceof Supplier) {
           // The supplier returns null on parse error in our fetcher.
           jsonData = ((Supplier<Object>) jf).get();
         }
+        if (Boolean.TRUE.equals(Struct.getprop(fm, "unreadable"))) {
+          RuntimeException failed = status >= 200 && status < 300 ? null
+              : ctx.makeError("request_status",
+                  "request: " + status + ": " + Struct.getprop(fm, "statusText"));
+          bodyErr = Response.unreadableBody(ctx, status, headers, Struct.getprop(fm, "body"),
+              fetchdef.get("headers"), failed);
+        }
       }
 
-      out.put("ok", status >= 200 && status < 300);
+      out.put("ok", bodyErr == null && status >= 200 && status < 300);
       out.put("status", status);
       out.put("headers", headers);
       out.put("data", jsonData);
+      if (bodyErr != null) {
+        out.put("err", utility.clean.apply(ctx, bodyErr));
+      }
       return out;
     }
 

package/project/.sdk/tm/java/core/SdkEntity.java

@@ -18,6 +18,8 @@ public interface SdkEntity extends Entity {
 
   Object update(Map<String, Object> reqdata, Map<String, Object> ctrl);
 
+  Object patch(Map<String, Object> reqdata, Map<String, Object> ctrl);
+
   Object remove(Map<String, Object> reqmatch, Map<String, Object> ctrl);
 
   // Runs `action` through the pipeline and returns a Stream over result

package/project/.sdk/tm/java/core/Spec.java

@@ -1,5 +1,6 @@
 package JAVAPACKAGE.core;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -21,6 +22,9 @@ public class Spec {
   public Object body;
   public String url = "";
   public String path = "";
+  // The query parameters prepareAuth placed: the credential, which the
+  // request sends and the entity's match leaves out.
+  public List<String> authquery = new ArrayList<>();
 
   public Spec() {}
 

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

@@ -1,5 +1,6 @@
 package JAVAPACKAGE.feature;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -30,6 +31,38 @@ public class TestFeature extends BaseFeature {
   // parameter — the rule makePoint uses to tell the entity's own route from a
   // cross-reference that also returns it.
   @SuppressWarnings("unchecked")
+  // The record the mock keeps: the request data without `$body`, which only the
+  // wire carries.
+  private static Map<String, Object> record(Map<String, Object> reqdata) {
+    if (reqdata == null) {
+      return null;
+    }
+    Map<String, Object> out = new LinkedHashMap<>(reqdata);
+    out.remove("$body");
+    return out;
+  }
+
+  private static final java.util.regex.Pattern ITEM_ENVELOPE_RE =
+      java.util.regex.Pattern.compile("^`\\.([^.`$]+)`$");
+
+  // The key a list's response transform
+  // ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record under.
+  private static String itemEnvelopeKey(Object restf) {
+    if (!(restf instanceof List) || 3 != ((List<?>) restf).size()) {
+      return null;
+    }
+    List<?> spec = (List<?>) restf;
+    if (!"`$EACH`".equals(spec.get(0)) || !"body".equals(spec.get(1)) || !(spec.get(2) instanceof Map)) {
+      return null;
+    }
+    Object merge = ((Map<?, ?>) spec.get(2)).get("`$MERGE`");
+    if (!(merge instanceof String)) {
+      return null;
+    }
+    java.util.regex.Matcher m = ITEM_ENVELOPE_RE.matcher((String) merge);
+    return m.matches() ? m.group(1) : null;
+  }
+
   private static int pointPartsLen(Object point) {
     Object parts = Struct.getprop(point, "parts");
     return parts instanceof List ? ((List<Object>) parts).size() : 0;
@@ -105,6 +138,16 @@ public class TestFeature extends BaseFeature {
     }
     Object tm = Struct.getprop(ctx.point, "transform");
     Object restf = Struct.getprop(tm, "res");
+    String key = itemEnvelopeKey(restf);
+    if (null != key && data instanceof List) {
+      List<Object> items = new ArrayList<>();
+      for (Object item : (List<?>) data) {
+        Map<String, Object> wrapped = new LinkedHashMap<>();
+        wrapped.put(key, item);
+        items.add(wrapped);
+      }
+      return items;
+    }
     if (!(restf instanceof String)) {
       return data;
     }
@@ -199,7 +242,7 @@ public class TestFeature extends BaseFeature {
       Object out = Struct.clone(found);
       return respond(ctx, 200, out, null);
     }
-    else if ("update".equals(op.name)) {
+    else if ("update".equals(op.name) || "patch".equals(op.name)) {
       // Match the existing entity by id only (or its alias). Reqdata
       // also contains the new field values, which would otherwise
       // cause select to filter out the entity we want to update.
@@ -233,7 +276,7 @@ public class TestFeature extends BaseFeature {
         return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       if (ent instanceof Map && ctx.reqdata != null) {
-        Struct.merge(Struct.jt(ent, ctx.reqdata));
+        Struct.merge(Struct.jt(ent, record(ctx.reqdata)));
       }
       Struct.delprop(ent, "$KEY");
       Object out = Struct.clone(ent);
@@ -261,7 +304,7 @@ public class TestFeature extends BaseFeature {
             r.nextInt(0x10000), r.nextInt(0x10000));
       }
 
-      Object ent = Struct.clone(ctx.reqdata);
+      Object ent = Struct.clone(record(ctx.reqdata));
       if (ent instanceof Map) {
         Map<String, Object> entm = (Map<String, Object>) ent;
         entm.put("id", id);

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

@@ -5,6 +5,8 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.LongSupplier;
 
 import JAVAPACKAGE.core.Context;
 import JAVAPACKAGE.core.SdkClient;
@@ -52,29 +54,41 @@ public class TimeoutFeature extends BaseFeature {
       return inner.fetch(ctx, url, fetchdef);
     }
 
-    CompletableFuture<Object> fut =
-        CompletableFuture.supplyAsync(() -> inner.fetch(ctx, url, fetchdef));
+    // The deadline runs from here, not from the wait below: a caller paused
+    // between the two would otherwise find a late response complete and take
+    // it. The worker notes when it finished, so a response or a failure after
+    // the deadline is a timeout however late the caller looks.
+    final LongSupplier now = FeatureOptions.foptNow(this.options);
+    final long start = now.getAsLong();
+    final AtomicLong arrived = new AtomicLong(Long.MAX_VALUE);
+    CompletableFuture<Object> fut = CompletableFuture.supplyAsync(() -> {
+      try {
+        return inner.fetch(ctx, url, fetchdef);
+      }
+      finally {
+        arrived.set(now.getAsLong());
+      }
+    });
 
     try {
-      return fut.get(deadline, TimeUnit.MILLISECONDS);
-    }
-    catch (TimeoutException e) {
-      track(deadline);
-      throw ctx.makeError("timeout",
-          "Request exceeded timeout of " + deadline + "ms");
-    }
-    catch (java.util.concurrent.ExecutionException e) {
-      Throwable cause = e.getCause();
-      if (cause instanceof CompletionException && cause.getCause() != null) {
-        cause = cause.getCause();
+      long remaining = Math.max(0L, deadline - (now.getAsLong() - start));
+      Object out;
+      try {
+        out = fut.get(remaining, TimeUnit.MILLISECONDS);
       }
-      if (cause instanceof RuntimeException) {
-        throw (RuntimeException) cause;
+      catch (java.util.concurrent.ExecutionException e) {
+        if (deadline < arrived.get() - start) {
+          throw timeout(ctx, deadline);
+        }
+        throw unwrap(e);
       }
-      if (cause instanceof Error) {
-        throw (Error) cause;
+      if (deadline < arrived.get() - start) {
+        throw timeout(ctx, deadline);
       }
-      throw new RuntimeException(cause);
+      return out;
+    }
+    catch (TimeoutException e) {
+      throw timeout(ctx, deadline);
     }
     catch (InterruptedException e) {
       Thread.currentThread().interrupt();
@@ -82,6 +96,25 @@ public class TimeoutFeature extends BaseFeature {
     }
   }
 
+  private static RuntimeException unwrap(java.util.concurrent.ExecutionException e) {
+    Throwable cause = e.getCause();
+    if (cause instanceof CompletionException && cause.getCause() != null) {
+      cause = cause.getCause();
+    }
+    if (cause instanceof RuntimeException) {
+      return (RuntimeException) cause;
+    }
+    if (cause instanceof Error) {
+      throw (Error) cause;
+    }
+    return new RuntimeException(cause);
+  }
+
+  private RuntimeException timeout(Context ctx, int deadline) {
+    track(deadline);
+    return ctx.makeError("timeout", "Request exceeded timeout of " + deadline + "ms");
+  }
+
   private void track(int deadline) {
     this.count++;
     this.ms = deadline;

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

@@ -205,6 +205,8 @@ public class ValidateFeature extends BaseFeature {
     // fields will never name it - and under `strict` every custom-action call
     // would be rejected for the one key that made it reachable.
     out.remove("$action");
+    // Nor is `$body`, the raw request body.
+    out.remove("$body");
 
     return out;
   }