@voxgig/sdkgen 4.0.0 → 4.1.0

package/project/.sdk/tm/c/feature/test.c

@@ -10,10 +10,48 @@
 #include <stdlib.h>
 #include <string.h>
 
+// THE MOCK HAS TO AGREE WITH THE MODEL.
+//
+// A point carrying `transform.res: `body.item`` describes an API that answers
+// {"item": {...}}, and the response transform unwraps that key on the way
+// back. Handing back the bare payload means the transform unwraps a property
+// that is not there and the caller gets nothing — a mock that only ever
+// simulates APIs whose responses happen to be unwrapped.
+//
+// univec's list op declares `body.data`, so every list returned zero items
+// while the fixture plainly held two. Mirrors the go/ts/lua/php mocks, which
+// already wrap; rust, c and zig were the three that did not.
+static voxgig_value* envelope(Context* ctx, voxgig_value* data) {
+  if (v_is_noval(data) || v_is_null(data)) {
+    return data;
+  }
+  voxgig_value* tm = getp(ctx->point, "transform");
+  const char* spec = get_str(tm, "res");
+  if (NULL == spec) {
+    return data;
+  }
+  // Exactly `body.<key>`; a deeper path is not an envelope this mock can
+  // synthesise, so it is left alone rather than guessed at.
+  size_t n = strlen(spec);
+  if (n < 8 || 0 != strncmp(spec, "`body.", 6) || '`' != spec[n - 1]) {
+    return data;
+  }
+  size_t inner_len = n - 7;
+  if (0 == inner_len || NULL != memchr(spec + 6, '.', inner_len)) {
+    return data;
+  }
+  char* inner = (char*)malloc(inner_len + 1);
+  memcpy(inner, spec + 6, inner_len);
+  inner[inner_len] = '\0';
+  voxgig_value* out = cmap(1, inner, data);
+  free(inner);
+  return out;
+}
+
 // respond builds a transport-shaped response the result pipeline understands.
-static voxgig_value* respond(int64_t status, voxgig_value* data) {
+static voxgig_value* respond(Context* ctx, int64_t status, voxgig_value* data) {
   return cmap(4, "status", v_num((double)status), "statusText", v_str("OK"), "json",
-              json_thunk(data), "body", v_str("not-used"));
+              json_thunk(envelope(ctx, data)), "body", v_str("not-used"));
 }
 
 // For single-entity ops (load, remove) with an empty explicit match, fall
@@ -109,19 +147,19 @@ static voxgig_value* test_fetch(voxgig_value* entity, Context* ctx, const char*
     voxgig_value* found = voxgig_select(entmap, args);
     voxgig_value* ent = voxgig_getelem(found, v_int(0), NULL);
     if (v_is_noval(ent) || v_is_null(ent)) {
-      voxgig_value* r = respond(404, v_undef());
+      voxgig_value* r = respond(ctx, 404, v_undef());
       setp(r, "statusText", v_str("Not found"));
       return r;
     }
     voxgig_delprop(ent, v_str("$KEY"));
-    return respond(200, voxgig_clone(ent));
+    return respond(ctx, 200, voxgig_clone(ent));
   }
 
   if (strcmp(opname, "list") == 0) {
     voxgig_value* args = build_args(ctx, ctx->reqmatch);
     voxgig_value* found = voxgig_select(entmap, args);
     if (v_is_noval(found) || v_is_null(found)) {
-      voxgig_value* r = respond(404, v_undef());
+      voxgig_value* r = respond(ctx, 404, v_undef());
       setp(r, "statusText", v_str("Not found"));
       return r;
     }
@@ -131,7 +169,7 @@ static voxgig_value* test_fetch(voxgig_value* entity, Context* ctx, const char*
         voxgig_delprop(l->items[i], v_str("$KEY"));
       }
     }
-    return respond(200, voxgig_clone(found));
+    return respond(ctx, 200, voxgig_clone(found));
   }
 
   if (strcmp(opname, "update") == 0) {
@@ -168,7 +206,7 @@ static voxgig_value* test_fetch(voxgig_value* entity, Context* ctx, const char*
       }
     }
     if (v_is_noval(ent) || v_is_null(ent)) {
-      voxgig_value* r = respond(404, v_undef());
+      voxgig_value* r = respond(ctx, 404, v_undef());
       setp(r, "statusText", v_str("Not found"));
       return r;
     }
@@ -179,7 +217,7 @@ static voxgig_value* test_fetch(voxgig_value* entity, Context* ctx, const char*
       }
     }
     voxgig_delprop(ent, v_str("$KEY"));
-    return respond(200, voxgig_clone(ent));
+    return respond(ctx, 200, voxgig_clone(ent));
   }
 
   if (strcmp(opname, "remove") == 0) {
@@ -192,7 +230,7 @@ static voxgig_value* test_fetch(voxgig_value* entity, Context* ctx, const char*
       voxgig_value* id = getp(ent, "id");
       voxgig_delprop(entmap, id);
     }
-    return respond(200, v_undef());
+    return respond(ctx, 200, v_undef());
   }
 
   if (strcmp(opname, "create") == 0) {
@@ -216,12 +254,12 @@ static voxgig_value* test_fetch(voxgig_value* entity, Context* ctx, const char*
         setp(entmap, voxgig_as_string(id), ent);
       }
       voxgig_delprop(ent, v_str("$KEY"));
-      return respond(200, voxgig_clone(ent));
+      return respond(ctx, 200, voxgig_clone(ent));
     }
-    return respond(200, ent);
+    return respond(ctx, 200, ent);
   }
 
-  voxgig_value* r = respond(404, v_undef());
+  voxgig_value* r = respond(ctx, 404, v_undef());
   setp(r, "statusText", v_str("Unknown operation"));
   return r;
 }

package/project/.sdk/tm/cpp/feature/test.hpp

@@ -57,11 +57,34 @@ public:
   }
 
 private:
-  Value respond(int status, const Value& data, const Value& extra) {
+  // THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+  // `transform.res: `body.item`` describes an API that answers {"item": {...}}
+  // and the response transform unwraps that key on the way back. Returning the
+  // bare payload means the transform unwraps a property that is not there and
+  // the caller gets nothing. Mirrors the go/ts/lua/php mocks.
+  Value envelope(CtxPtr ctx, const Value& data) {
+    if (is_nullish(data) || !ctx) return data;
+    Value tm = getp(ctx->point, "transform");
+    Value restf = getp(tm, "res");
+    if (!restf.is_string()) return data;
+    std::string spec = restf.as_string();
+    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    // synthesise, so it is left alone rather than guessed at.
+    if (spec.size() < 8) return data;
+    if (0 != spec.compare(0, 6, "`body.")) return data;
+    if ('`' != spec[spec.size() - 1]) return data;
+    std::string inner = spec.substr(6, spec.size() - 7);
+    if (inner.empty() || std::string::npos != inner.find('.')) return data;
+    Value wrapped = vmap();
+    map_put(wrapped, inner, data);
+    return wrapped;
+  }
+
+  Value respond(CtxPtr ctx, int status, const Value& data, const Value& extra) {
     Value out = vmap();
     map_put(out, "status", Value(status));
     map_put(out, "statusText", Value("OK"));
-    map_put(out, "json", json_thunk(data));
+    map_put(out, "json", json_thunk(envelope(ctx, data)));
     map_put(out, "body", Value("not-used"));
     if (extra.is_map()) {
       for (const auto& kv : *extra.as_map()) map_put(out, kv.first, kv.second);
@@ -100,10 +123,10 @@ private:
       Value args = buildArgs(ctx, op, resolveMatch(ctx, ctx->reqmatch));
       std::vector<Value> found = Struct::select(entmap, args);
       Value ent = found.empty() ? Value::undef() : found[0];
-      if (is_nullish(ent)) return respond(404, Value(nullptr), extra1("statusText", Value("Not found")));
+      if (is_nullish(ent)) return respond(ctx, 404, Value(nullptr), extra1("statusText", Value("Not found")));
       Struct::delprop(ent, Value("$KEY"));
       Value out = Struct::clone(ent);
-      return respond(200, out, Value::undef());
+      return respond(ctx, 200, out, Value::undef());
     } else if (op->name == "list") {
       Value args = buildArgs(ctx, op, ctx->reqmatch);
       std::vector<Value> found = Struct::select(entmap, args);
@@ -113,7 +136,7 @@ private:
         outlist.as_list()->push_back(item);
       }
       Value out = Struct::clone(outlist);
-      return respond(200, out, Value::undef());
+      return respond(ctx, 200, out, Value::undef());
     } else if (op->name == "update") {
       Value updateMatch = vmap();
       if (ctx->reqdata.is_map()) {
@@ -141,13 +164,13 @@ private:
           if (kv.second.is_map()) { ent = kv.second; break; }
         }
       }
-      if (is_nullish(ent)) return respond(404, Value(nullptr), extra1("statusText", Value("Not found")));
+      if (is_nullish(ent)) return respond(ctx, 404, Value(nullptr), extra1("statusText", Value("Not found")));
       if (ent.is_map() && ctx->reqdata.is_map()) {
         for (const auto& kv : *ctx->reqdata.as_map()) map_put(ent, kv.first, kv.second);
       }
       Struct::delprop(ent, Value("$KEY"));
       Value out = Struct::clone(ent);
-      return respond(200, out, Value::undef());
+      return respond(ctx, 200, out, Value::undef());
     } else if (op->name == "remove") {
       Value args = buildArgs(ctx, op, resolveMatch(ctx, ctx->reqmatch));
       std::vector<Value> found = Struct::select(entmap, args);
@@ -156,7 +179,7 @@ private:
         Value id = getp(ent, "id", Value(nullptr));
         Struct::delprop(entmap, id);
       }
-      return respond(200, Value(nullptr), Value::undef());
+      return respond(ctx, 200, Value(nullptr), Value::undef());
     } else if (op->name == "create") {
       buildArgs(ctx, op, ctx->reqdata);
       Value id = ctx->utility->param(ctx, Value("id"));
@@ -177,12 +200,12 @@ private:
         if (id.is_string()) map_put(entmap, id.as_string(), ent);
         Struct::delprop(ent, Value("$KEY"));
         Value out = Struct::clone(ent);
-        return respond(200, out, Value::undef());
+        return respond(ctx, 200, out, Value::undef());
       }
-      return respond(200, ent, Value::undef());
+      return respond(ctx, 200, ent, Value::undef());
     }
 
-    return respond(404, Value(nullptr), extra1("statusText", Value("Unknown operation")));
+    return respond(ctx, 404, Value(nullptr), extra1("statusText", Value("Unknown operation")));
   }
 
   // ---- net simulation over the mock -----------------------------------

package/project/.sdk/tm/csharp/feature/TestFeature.cs

@@ -45,14 +45,40 @@ public class TestFeature : BaseFeature
 
         FetcherFunc testFetcher = (ctx2, _fullurl, _fetchdef) =>
         {
-            static Dictionary<string, object?> Respond(int status, object? data,
+            // THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+            // `transform.res: `body.item`` describes an API that answers
+            // {"item": {...}}, and the response transform unwraps that key on
+            // the way back. Returning the bare payload means the transform
+            // unwraps a property that is not there and the caller gets
+            // nothing. Mirrors the go/ts/lua/php mocks.
+            //
+            // NOT `static`: it closes over ctx2 to read the point, which is
+            // how go's mock does it too.
+            object? Envelope(object? data)
+            {
+                if (data == null || ctx2.Point == null) { return data; }
+                var tm = StructUtils.GetProp(ctx2.Point, "transform");
+                if (StructUtils.GetProp(tm, "res") is not string spec) { return data; }
+                // Exactly `body.<key>`; a deeper path is not an envelope this
+                // mock can synthesise, so it is left alone.
+                if (!spec.StartsWith("`body.") || !spec.EndsWith("`") || spec.Length < 8)
+                {
+                    return data;
+                }
+                var inner = spec.Substring(6, spec.Length - 7);
+                if (inner.Length == 0 || inner.Contains('.')) { return data; }
+                return new Dictionary<string, object?> { [inner] = data };
+            }
+
+            Dictionary<string, object?> Respond(int status, object? data,
                 Dictionary<string, object?>? extra)
             {
+                var payload = Envelope(data);
                 var res = new Dictionary<string, object?>
                 {
                     ["status"] = status,
                     ["statusText"] = "OK",
-                    ["json"] = (Func<object?>)(() => data),
+                    ["json"] = (Func<object?>)(() => payload),
                     ["body"] = "not-used",
                 };
                 if (extra != null)

package/project/.sdk/tm/elixir/lib/projectname/feature/test.ex

@@ -47,12 +47,39 @@ defmodule ProjectName.Feature.Test do
     nil
   end
 
-  defp respond(status, data, extra \\ nil) do
+  # THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+  # `transform.res: `body.item`` describes an API that answers {"item": {...}}
+  # and the response transform unwraps that key on the way back. Returning the
+  # bare payload means the transform unwraps a property that is not there and
+  # the caller gets nothing. Mirrors the go/ts/lua/php mocks.
+  defp envelope(fctx, data) do
+    spec = S.getprop(S.getprop(S.getprop(fctx, "point"), "transform"), "res")
+
+    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    # synthesise, so it is left alone rather than guessed at.
+    case {data, spec} do
+      {nil, _} ->
+        data
+
+      {_, s} when is_binary(s) ->
+        case Regex.run(~r/^`body\.([^`.]+)`$/, s) do
+          [_, inner] -> S.jm([inner, data])
+          _ -> data
+        end
+
+      _ ->
+        data
+    end
+  end
+
+  defp respond(fctx, status, data, extra \\ nil) do
+    payload = envelope(fctx, data)
+
     out =
       S.jm([
         "status", status,
         "statusText", "OK",
-        "json", fn -> data end,
+        "json", fn -> payload end,
         "body", "not-used"
       ])
 
@@ -87,10 +114,10 @@ defmodule ProjectName.Feature.Test do
         ent = S.getelem(found, 0)
 
         if ent == nil do
-          respond(404, nil, S.jm(["statusText", "Not found"]))
+          respond(fctx, 404, nil, S.jm(["statusText", "Not found"]))
         else
           S.delprop(ent, "$KEY")
-          respond(200, S.clone(ent))
+          respond(fctx, 200, S.clone(ent))
         end
 
       "list" ->
@@ -98,13 +125,13 @@ defmodule ProjectName.Feature.Test do
         found = S.select(entmap, args)
 
         if found == nil do
-          respond(404, nil, S.jm(["statusText", "Not found"]))
+          respond(fctx, 404, nil, S.jm(["statusText", "Not found"]))
         else
           if S.islist(found) and S.size(found) > 0 do
             Enum.each(0..(S.size(found) - 1), fn i -> S.delprop(S.getelem(found, i), "$KEY") end)
           end
 
-          respond(200, S.clone(found))
+          respond(fctx, 200, S.clone(found))
         end
 
       "update" ->
@@ -143,14 +170,14 @@ defmodule ProjectName.Feature.Test do
           end
 
         if ent == nil do
-          respond(404, nil, S.jm(["statusText", "Not found"]))
+          respond(fctx, 404, nil, S.jm(["statusText", "Not found"]))
         else
           if S.ismap(ent) and reqdata != nil do
             Enum.each(H.entries(reqdata), fn {k, v} -> S.setprop(ent, k, v) end)
           end
 
           S.delprop(ent, "$KEY")
-          respond(200, S.clone(ent))
+          respond(fctx, 200, S.clone(ent))
         end
 
       "remove" ->
@@ -163,7 +190,7 @@ defmodule ProjectName.Feature.Test do
           S.delprop(entmap, eid)
         end
 
-        respond(200, nil)
+        respond(fctx, 200, nil)
 
       "create" ->
         build_args(f, fctx, op, S.getprop(fctx, "reqdata"))
@@ -175,13 +202,13 @@ defmodule ProjectName.Feature.Test do
           S.setprop(ent, "id", eid)
           if is_binary(eid), do: S.setprop(entmap, eid, ent)
           S.delprop(ent, "$KEY")
-          respond(200, S.clone(ent))
+          respond(fctx, 200, S.clone(ent))
         else
-          respond(200, ent)
+          respond(fctx, 200, ent)
         end
 
       _ ->
-        respond(404, nil, S.jm(["statusText", "Unknown operation"]))
+        respond(fctx, 404, nil, S.jm(["statusText", "Unknown operation"]))
     end
   end
 

package/project/.sdk/tm/go/test/runner_test.go

@@ -216,7 +216,7 @@ func getSpec(spec map[string]any, keys ...string) map[string]any {
 type RunSubject func(entry map[string]any) (any, error)
 
 // PENDING sections are the ones deliberately left empty in the shared corpus
-// (.sdk/test/primary/<name>.aontu). Everything else MUST contribute cases.
+// (.sdk/test/primary/<name>.aon). Everything else MUST contribute cases.
 var pendingSections = map[string]bool{
 	"fetcher": true, "makeFetchDef": true, "makeResult": true,
 	"featureAdd": true, "featureHook": true, "featureInit": true,

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

@@ -90,11 +90,45 @@ public class TestFeature extends BaseFeature {
     }
   }
 
-  private Map<String, Object> respond(int status, Object data, Map<String, Object> extra) {
+  // THE MOCK HAS TO AGREE WITH THE MODEL.
+  //
+  // A point carrying `transform.res: `body.item`` describes an API that
+  // answers {"item": {...}}, and the response transform unwraps that key on
+  // the way back. Handing back the bare payload means the transform unwraps a
+  // property that is not there and the caller gets nothing — a mock that only
+  // ever simulates APIs whose responses happen to be unwrapped.
+  //
+  // Mirrors the go/ts/lua/php mocks, which already wrap.
+  private Object envelope(Context ctx, Object data) {
+    if (null == data || null == ctx || null == ctx.point) {
+      return data;
+    }
+    Object tm = Struct.getprop(ctx.point, "transform");
+    Object restf = Struct.getprop(tm, "res");
+    if (!(restf instanceof String)) {
+      return data;
+    }
+    String spec = (String) restf;
+    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    // synthesise, so it is left alone rather than guessed at.
+    if (!spec.startsWith("`body.") || !spec.endsWith("`") || spec.length() < 8) {
+      return data;
+    }
+    String inner = spec.substring(6, spec.length() - 1);
+    if (inner.isEmpty() || inner.contains(".")) {
+      return data;
+    }
+    Map<String, Object> wrapped = new LinkedHashMap<>();
+    wrapped.put(inner, data);
+    return wrapped;
+  }
+
+  private Map<String, Object> respond(Context ctx, int status, Object data, Map<String, Object> extra) {
+    Object payload = envelope(ctx, data);
     Map<String, Object> out = new LinkedHashMap<>();
     out.put("status", status);
     out.put("statusText", "OK");
-    out.put("json", (Supplier<Object>) () -> data);
+    out.put("json", (Supplier<Object>) () -> payload);
     out.put("body", "not-used");
     if (extra != null) {
       out.putAll(extra);
@@ -142,23 +176,23 @@ public class TestFeature extends BaseFeature {
       List<Object> found = Struct.select(entmap, args);
       Object ent = Struct.getelem(found, 0);
       if (ent == null) {
-        return respond(404, null, extra("statusText", "Not found"));
+        return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       Struct.delprop(ent, "$KEY");
       Object out = Struct.clone(ent);
-      return respond(200, out, null);
+      return respond(ctx, 200, out, null);
     }
     else if ("list".equals(op.name)) {
       Object args = buildArgs(ctx, op, ctx.reqmatch);
       List<Object> found = Struct.select(entmap, args);
       if (found == null) {
-        return respond(404, null, extra("statusText", "Not found"));
+        return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       for (Object item : found) {
         Struct.delprop(item, "$KEY");
       }
       Object out = Struct.clone(found);
-      return respond(200, out, null);
+      return respond(ctx, 200, out, null);
     }
     else if ("update".equals(op.name)) {
       // Match the existing entity by id only (or its alias). Reqdata
@@ -198,14 +232,14 @@ public class TestFeature extends BaseFeature {
         }
       }
       if (ent == null) {
-        return respond(404, null, extra("statusText", "Not found"));
+        return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       if (ent instanceof Map && ctx.reqdata != null) {
         ((Map<String, Object>) ent).putAll(ctx.reqdata);
       }
       Struct.delprop(ent, "$KEY");
       Object out = Struct.clone(ent);
-      return respond(200, out, null);
+      return respond(ctx, 200, out, null);
     }
     else if ("remove".equals(op.name)) {
       Object args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch));
@@ -217,7 +251,7 @@ public class TestFeature extends BaseFeature {
         Object id = Struct.getprop(ent, "id", null);
         Struct.delprop(entmap, id);
       }
-      return respond(200, null, null);
+      return respond(ctx, 200, null, null);
     }
     else if ("create".equals(op.name)) {
       buildArgs(ctx, op, ctx.reqdata);
@@ -238,12 +272,12 @@ public class TestFeature extends BaseFeature {
         }
         Struct.delprop(entm, "$KEY");
         Object out = Struct.clone(entm);
-        return respond(200, out, null);
+        return respond(ctx, 200, out, null);
       }
-      return respond(200, ent, null);
+      return respond(ctx, 200, ent, null);
     }
 
-    return respond(404, null, extra("statusText", "Unknown operation"));
+    return respond(ctx, 404, null, extra("statusText", "Unknown operation"));
   }
 
   // makeNetsim wraps a transport with simulated network conditions: latency

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

@@ -54,11 +54,29 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
     }
   }
 
-  private fun respond(status: Int, data: Any?, extra: MutableMap<String, Any?>?): MutableMap<String, Any?> {
+  // THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+  // `transform.res: `body.item`` describes an API that answers {"item": {...}}
+  // and the response transform unwraps that key on the way back. Returning the
+  // bare payload means the transform unwraps a property that is not there and
+  // the caller gets nothing. Mirrors the go/ts/lua/php mocks.
+  private fun envelope(ctx: Context?, data: Any?): Any? {
+    if (null == data || null == ctx) return data
+    val tm = Struct.getprop(ctx.point, "transform")
+    val restf = Struct.getprop(tm, "res") as? String ?: return data
+    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    // synthesise, so it is left alone rather than guessed at.
+    if (!restf.startsWith("`body.") || !restf.endsWith("`") || restf.length < 8) return data
+    val inner = restf.substring(6, restf.length - 1)
+    if (inner.isEmpty() || inner.contains(".")) return data
+    return linkedMapOf<String, Any?>(inner to data)
+  }
+
+  private fun respond(ctx: Context?, status: Int, data: Any?, extra: MutableMap<String, Any?>?): MutableMap<String, Any?> {
+    val payload = envelope(ctx, data)
     val out = linkedMapOf<String, Any?>()
     out["status"] = status
     out["statusText"] = "OK"
-    out["json"] = Supplier<Any?> { data }
+    out["json"] = Supplier<Any?> { payload }
     out["body"] = "not-used"
     if (extra != null) {
       out.putAll(extra)
@@ -102,11 +120,11 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
         val found = Struct.select(entmap, args)
         val ent = Struct.getelem(found, 0, null)
         if (ent == null) {
-          return respond(404, null, extra("statusText", "Not found"))
+          return respond(ctx, 404, null, extra("statusText", "Not found"))
         }
         Struct.delprop(ent, "\$KEY")
         val out = Struct.clone(ent)
-        return respond(200, out, null)
+        return respond(ctx, 200, out, null)
       }
       "list" -> {
         val args = buildArgs(ctx, op, ctx.reqmatch)
@@ -115,7 +133,7 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           Struct.delprop(item, "\$KEY")
         }
         val out = Struct.clone(found)
-        return respond(200, out, null)
+        return respond(ctx, 200, out, null)
       }
       "update" -> {
         // Match the existing entity by id only (or its alias).
@@ -148,14 +166,14 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           }
         }
         if (ent == null) {
-          return respond(404, null, extra("statusText", "Not found"))
+          return respond(ctx, 404, null, extra("statusText", "Not found"))
         }
         if (ent is MutableMap<*, *>) {
           (ent as MutableMap<String, Any?>).putAll(reqdata)
         }
         Struct.delprop(ent, "\$KEY")
         val out = Struct.clone(ent)
-        return respond(200, out, null)
+        return respond(ctx, 200, out, null)
       }
       "remove" -> {
         val args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch))
@@ -166,7 +184,7 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           val id = Struct.getprop(ent, "id", null)
           Struct.delprop(entmap, id)
         }
-        return respond(200, null, null)
+        return respond(ctx, 200, null, null)
       }
       "create" -> {
         buildArgs(ctx, op, ctx.reqdata)
@@ -189,13 +207,13 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           }
           Struct.delprop(entm, "\$KEY")
           val out = Struct.clone(entm)
-          return respond(200, out, null)
+          return respond(ctx, 200, out, null)
         }
-        return respond(200, ent, null)
+        return respond(ctx, 200, ent, null)
       }
     }
 
-    return respond(404, null, extra("statusText", "Unknown operation"))
+    return respond(ctx, 404, null, extra("statusText", "Unknown operation"))
   }
 
   // makeNetsim wraps a transport with simulated network conditions.