@voxgig/sdkgen 4.0.1 → 4.1.0

package/bin/voxgig-sdkgen

@@ -8,7 +8,7 @@ const { Shape, One, Skip } = require('shape')
 
 const { SdkGen } = require('../dist/sdkgen.js')
 
-const VERSION = '4.0.1'
+const VERSION = '4.1.0'
 const KONSOLE = console
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/sdkgen",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "main": "dist/sdkgen.js",
   "type": "commonjs",
   "engines": {

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/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.

package/project/.sdk/tm/perl/feature/test_feature.pm

@@ -51,12 +51,34 @@ sub init {
 
   my $test_self = $self;
 
+  # 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.
+  #
+  # Takes the PER-REQUEST context: the point is resolved per call, so the
+  # init-time $ctx this closure would otherwise capture is the wrong one.
+  my $envelope = sub {
+    my ($fctx, $data) = @_;
+    return $data unless defined $data;
+    return $data unless defined $fctx && defined $fctx->{point};
+    my $tm = ProjectNameHelpers::gp($fctx->{point}, 'transform');
+    my $spec = ProjectNameHelpers::gp($tm, 'res');
+    return $data unless defined $spec && !ref($spec);
+    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    # synthesise, so it is left alone rather than guessed at.
+    return $data unless $spec =~ /^`body\.([^`.]+)`$/;
+    return { $1 => $data };
+  };
+
   my $respond = sub {
-    my ($status, $data, $extra) = @_;
+    my ($fctx, $status, $data, $extra) = @_;
+    my $payload = $envelope->($fctx, $data);
     my $out = {
       'status' => $status,
       'statusText' => 'OK',
-      'json' => sub { $data },
+      'json' => sub { $payload },
       'body' => 'not-used',
     };
     if (Voxgig::Struct::ismap($extra)) {
@@ -92,22 +114,22 @@ sub init {
       my $args = $test_self->build_args($fctx, $op, $resolve_match->($fctx->{reqmatch}));
       my $found = Voxgig::Struct::select($entmap, $args);
       my $ent = ProjectNameHelpers::ge($found, 0);
-      return $respond->(404, undef, { 'statusText' => 'Not found' })
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Not found' })
         unless ProjectNameHelpers::rb_truthy($ent);
       Voxgig::Struct::delprop($ent, '$KEY');
       my $out = Voxgig::Struct::clone($ent);
-      return $respond->(200, $out, undef);
+      return $respond->($fctx, 200, $out, undef);
     }
     elsif ('list' eq $op->{name}) {
       my $args = $test_self->build_args($fctx, $op, $fctx->{reqmatch});
       my $found = Voxgig::Struct::select($entmap, $args);
-      return $respond->(404, undef, { 'statusText' => 'Not found' })
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Not found' })
         unless defined $found && !Voxgig::Struct::is_none($found);
       if (Voxgig::Struct::islist($found)) {
         Voxgig::Struct::delprop($_, '$KEY') for @$found;
       }
       my $out = Voxgig::Struct::clone($found);
-      return $respond->(200, $out, undef);
+      return $respond->($fctx, 200, $out, undef);
     }
     elsif ('update' eq $op->{name}) {
       # Match the existing entity by id only (or its alias). reqdata also
@@ -138,14 +160,14 @@ sub init {
           }
         }
       }
-      return $respond->(404, undef, { 'statusText' => 'Not found' })
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Not found' })
         unless ProjectNameHelpers::rb_truthy($ent);
       if (Voxgig::Struct::ismap($ent) && $fctx->{reqdata}) {
         $ent->{$_} = $fctx->{reqdata}{$_} for keys %{ $fctx->{reqdata} };
       }
       Voxgig::Struct::delprop($ent, '$KEY');
       my $out = Voxgig::Struct::clone($ent);
-      return $respond->(200, $out, undef);
+      return $respond->($fctx, 200, $out, undef);
     }
     elsif ('remove' eq $op->{name}) {
       my $args = $test_self->build_args($fctx, $op, $resolve_match->($fctx->{reqmatch}));
@@ -157,7 +179,7 @@ sub init {
         my $id = ProjectNameHelpers::gp($ent, 'id');
         Voxgig::Struct::delprop($entmap, $id);
       }
-      return $respond->(200, undef, undef);
+      return $respond->($fctx, 200, undef, undef);
     }
     elsif ('create' eq $op->{name}) {
       $test_self->build_args($fctx, $op, $fctx->{reqdata});
@@ -172,12 +194,12 @@ sub init {
         $entmap->{"$id"} = $ent if defined $id && !ref $id;
         Voxgig::Struct::delprop($ent, '$KEY');
         my $out = Voxgig::Struct::clone($ent);
-        return $respond->(200, $out, undef);
+        return $respond->($fctx, 200, $out, undef);
       }
-      return $respond->(200, $ent, undef);
+      return $respond->($fctx, 200, $ent, undef);
     }
     else {
-      return $respond->(404, undef, { 'statusText' => 'Unknown operation' });
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Unknown operation' });
     }
   };
 

package/project/.sdk/tm/rust/feature/test.rs

@@ -33,11 +33,40 @@ impl TestFeature {
     }
 }
 
-fn respond(status: i64, data: Value, extra: Vec<(&str, Value)>) -> Value {
+// 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.
+fn envelope(ctx: &Rc<Context>, data: Value) -> Value {
+    if data.is_noval() || data.is_null() {
+        return data;
+    }
+    let restf = crate::core::helpers::getpath(&["transform", "res"], &ctx.point.borrow());
+    if let Value::Str(spec) = 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 let Some(inner) = spec.strip_prefix("`body.").and_then(|r| r.strip_suffix('`')) {
+            if !inner.is_empty() && !inner.contains('.') {
+                return jo(vec![(inner, data)]);
+            }
+        }
+    }
+    data
+}
+
+fn respond(ctx: &Rc<Context>, status: i64, data: Value, extra: Vec<(&str, Value)>) -> Value {
+    let payload = envelope(ctx, data);
     let out = jo(vec![
         ("status", Value::Num(status as f64)),
         ("statusText", Value::str("OK")),
-        ("json", json_thunk(data)),
+        ("json", json_thunk(payload)),
         ("body", Value::str("not-used")),
     ]);
     for (k, v) in extra {
@@ -150,22 +179,20 @@ fn test_fetch(
             let found = vs::select(&entmap, &args);
             let ent = vs::get_elem(&found, &Value::Num(0.0), Value::Noval);
             if ent.is_noval() || ent.is_null() {
-                return Ok(respond(
-                    404,
+                return Ok(respond(ctx, 404,
                     Value::Noval,
                     vec![("statusText", Value::str("Not found"))],
                 ));
             }
             vs::del_prop(ent.clone(), &Value::str("$KEY"));
-            Ok(respond(200, vs::clone(&ent), vec![]))
+            Ok(respond(ctx, 200, vs::clone(&ent), vec![]))
         }
 
         "list" => {
             let args = build_args(ctx, &ctx.reqmatch.borrow().clone());
             let found = vs::select(&entmap, &args);
             if found.is_noval() || found.is_null() {
-                return Ok(respond(
-                    404,
+                return Ok(respond(ctx, 404,
                     Value::Noval,
                     vec![("statusText", Value::str("Not found"))],
                 ));
@@ -175,7 +202,7 @@ fn test_fetch(
                     vs::del_prop(item.clone(), &Value::str("$KEY"));
                 }
             }
-            Ok(respond(200, vs::clone(&found), vec![]))
+            Ok(respond(ctx, 200, vs::clone(&found), vec![]))
         }
 
         "update" => {
@@ -214,8 +241,7 @@ fn test_fetch(
                 }
             }
             if ent.is_noval() || ent.is_null() {
-                return Ok(respond(
-                    404,
+                return Ok(respond(ctx, 404,
                     Value::Noval,
                     vec![("statusText", Value::str("Not found"))],
                 ));
@@ -228,7 +254,7 @@ fn test_fetch(
                 }
             }
             vs::del_prop(ent.clone(), &Value::str("$KEY"));
-            Ok(respond(200, vs::clone(&ent), vec![]))
+            Ok(respond(ctx, 200, vs::clone(&ent), vec![]))
         }
 
         "remove" => {
@@ -242,7 +268,7 @@ fn test_fetch(
                 let id = getp(&ent, "id");
                 vs::del_prop(entmap, &id);
             }
-            Ok(respond(200, Value::Noval, vec![]))
+            Ok(respond(ctx, 200, Value::Noval, vec![]))
         }
 
         "create" => {
@@ -265,13 +291,12 @@ fn test_fetch(
                     setp(&entmap, id_str, ent.clone());
                 }
                 vs::del_prop(ent.clone(), &Value::str("$KEY"));
-                return Ok(respond(200, vs::clone(&ent), vec![]));
+                return Ok(respond(ctx, 200, vs::clone(&ent), vec![]));
             }
-            Ok(respond(200, ent, vec![]))
+            Ok(respond(ctx, 200, ent, vec![]))
         }
 
-        _ => Ok(respond(
-            404,
+        _ => Ok(respond(ctx, 404,
             Value::Noval,
             vec![("statusText", Value::str("Unknown operation"))],
         )),

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

@@ -40,8 +40,31 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
     else ctx.utility.fetcher = makeNetsim(net, testFetcher)
   }
 
-  private def respond(status: Int, data: Object, extra: JMap[String, Object]): JMap[String, Object] = {
-    val js: Supplier[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.
+  private def envelope(ctx: Context, data: Object): Object = {
+    if (data == null || ctx == null || ctx.point == null) return data
+    val tm = Struct.getprop(ctx.point, "transform")
+    Struct.getprop(tm, "res") match {
+      case spec: 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.startsWith("`body.") || !spec.endsWith("`") || spec.length < 8) return data
+        val inner = spec.substring(6, spec.length - 1)
+        if (inner.isEmpty || inner.contains(".")) return data
+        val wrapped = new java.util.LinkedHashMap[String, Object]()
+        wrapped.put(inner, data)
+        wrapped
+      case _ => data
+    }
+  }
+
+  private def respond(ctx: Context, status: Int, data: Object, extra: JMap[String, Object]): JMap[String, Object] = {
+    val payload = envelope(ctx, data)
+    val js: Supplier[Object] = () => payload
     val out = new LinkedHashMap[String, Object]()
     out.put("status", java.lang.Integer.valueOf(status))
     out.put("statusText", "OK")
@@ -85,18 +108,18 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
       val args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch))
       val found = Struct.select(entmap, args)
       val ent = Struct.getelem(found, java.lang.Integer.valueOf(0))
-      if (ent == null) return respond(404, null, extra("statusText", "Not found"))
+      if (ent == null) return respond(ctx, 404, null, extra("statusText", "Not found"))
       Struct.delprop(ent, "$KEY")
       val out = Struct.clone(ent)
-      respond(200, out, null)
+      respond(ctx, 200, out, null)
     } else if ("list" == op.name) {
       val args = buildArgs(ctx, op, ctx.reqmatch)
       val found = Struct.select(entmap, args)
-      if (found == null) return respond(404, null, extra("statusText", "Not found"))
+      if (found == null) return respond(ctx, 404, null, extra("statusText", "Not found"))
       val it = found.iterator()
       while (it.hasNext) Struct.delprop(it.next(), "$KEY")
       val out = Struct.clone(found)
-      respond(200, out, null)
+      respond(ctx, 200, out, null)
     } else if ("update" == op.name) {
       var updateMatch = new LinkedHashMap[String, Object]()
       if (ctx.reqdata != null) {
@@ -119,11 +142,11 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
           vit.next() match { case e: JMap[_, _] => ent = e; brk = true; case _ => }
         }
       }
-      if (ent == null) return respond(404, null, extra("statusText", "Not found"))
+      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 _ => }
       Struct.delprop(ent, "$KEY")
       val out = Struct.clone(ent)
-      respond(200, out, null)
+      respond(ctx, 200, out, null)
     } else if ("remove" == op.name) {
       val args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch))
       val found = Struct.select(entmap, args)
@@ -134,7 +157,7 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
           Struct.delprop(entmap, id)
         case _ =>
       }
-      respond(200, null, null)
+      respond(ctx, 200, null, null)
     } else if ("create" == op.name) {
       buildArgs(ctx, op, ctx.reqdata)
       var id = ctx.utility.param(ctx, "id")
@@ -153,11 +176,11 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
           id match { case s: String => entmap.put(s, entm); case _ => }
           Struct.delprop(entm, "$KEY")
           val out = Struct.clone(entm)
-          respond(200, out, null)
-        case _ => respond(200, ent, null)
+          respond(ctx, 200, out, null)
+        case _ => respond(ctx, 200, ent, null)
       }
     } else {
-      respond(404, null, extra("statusText", "Unknown operation"))
+      respond(ctx, 404, null, extra("statusText", "Unknown operation"))
     }
   }
 

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -5,11 +5,32 @@
 
 import Foundation
 
-private func testRespond(_ status: Int, _ data: Value, _ extra: VMap?) -> Value {
+// 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 func testEnvelope(_ ctx: Context, _ data: Value) -> Value {
+  if case .noval = data { return data }
+  if case .null = data { return data }
+  guard let point = ctx.point else { return data }
+  guard case .map(let tm)? = point.entries["transform"] else { return data }
+  guard case .string(let spec)? = tm.entries["res"] else { 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.
+  guard spec.hasPrefix("`body."), spec.hasSuffix("`"), spec.count >= 8 else { return data }
+  let inner = String(spec.dropFirst(6).dropLast(1))
+  guard !inner.isEmpty, !inner.contains(".") else { return data }
+  let wrapped = VMap()
+  wrapped.entries[inner] = data
+  return .map(wrapped)
+}
+
+private func testRespond(_ ctx: Context, _ status: Int, _ data: Value, _ extra: VMap?) -> Value {
   let res = VMap()
   res.entries["status"] = .int(Int64(status))
   res.entries["statusText"] = .string("OK")
-  let captured = data
+  let captured = testEnvelope(ctx, data)
   res.entries["json"] = .nat({ () -> Value in captured } as NativeCall0)
   res.entries["body"] = .string("not-used")
   if let extra = extra {
@@ -151,22 +172,22 @@ public final class TestFeature: BaseFeature {
         if isNil(ent) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(404, .noval, extra)
+          return testRespond(ctx, 404, .noval, extra)
         }
         delprop(ent, .string("$KEY"))
-        return testRespond(200, clone(ent), nil)
+        return testRespond(ctx, 200, clone(ent), nil)
       } else if op.name == "list" {
         let args = testBuildArgs(ctx2, op, ctx2.reqmatch)
         let found = select(.map(entmap), args)
         if isNil(found) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(404, .noval, extra)
+          return testRespond(ctx, 404, .noval, extra)
         }
         if let fl = found.asList {
           for item in fl.items { delprop(item, .string("$KEY")) }
         }
-        return testRespond(200, clone(found), nil)
+        return testRespond(ctx, 200, clone(found), nil)
       } else if op.name == "update" {
         var updateMatch = VMap()
         if let idv = ctx2.reqdata.entries["id"] {
@@ -188,13 +209,13 @@ public final class TestFeature: BaseFeature {
         if isNil(ent) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(404, .noval, extra)
+          return testRespond(ctx, 404, .noval, extra)
         }
         if let entm = ent.asMap {
           for (k, v) in ctx2.reqdata.entries { entm.entries[k] = v }
         }
         delprop(ent, .string("$KEY"))
-        return testRespond(200, clone(ent), nil)
+        return testRespond(ctx, 200, clone(ent), nil)
       } else if op.name == "remove" {
         let args = testBuildArgs(ctx2, op, testResolveMatch(ctx2, ctx2.reqmatch))
         let found = select(.map(entmap), args)
@@ -203,7 +224,7 @@ public final class TestFeature: BaseFeature {
           let id = gp(entm2, "id")
           delprop(.map(entmap), id)
         }
-        return testRespond(200, .noval, nil)
+        return testRespond(ctx, 200, .noval, nil)
       } else if op.name == "create" {
         _ = testBuildArgs(ctx2, op, ctx2.reqdata)
         var id = ctx2.utility!.param(ctx2, .string("id"))
@@ -218,14 +239,14 @@ public final class TestFeature: BaseFeature {
           entm.entries["id"] = id
           if let idStr = id.asString { entmap.entries[idStr] = .map(entm) }
           delprop(.map(entm), .string("$KEY"))
-          return testRespond(200, clone(.map(entm)), nil)
+          return testRespond(ctx, 200, clone(.map(entm)), nil)
         }
-        return testRespond(200, ent, nil)
+        return testRespond(ctx, 200, ent, nil)
       }
 
       let extra = VMap()
       extra.entries["statusText"] = .string("Unknown operation")
-      return testRespond(404, .noval, extra)
+      return testRespond(ctx, 404, .noval, extra)
     }
 
     // Optional network behaviour simulation over the mock transport.

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

@@ -93,11 +93,38 @@ fn fixIds(_: Allocator, key: ?[]const u8, val: Value, _: Value, path: []const []
     return val;
 }
 
-fn respond(status: i64, data: Value, extra: []const h.Pair) Value {
+// 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.
+fn envelope(ctx: *Context, data: Value) Value {
+    if (data == .undef or data == .null) return data;
+    const restf = h.getpath(&.{ "transform", "res" }, ctx.point);
+    if (restf != .string) return data;
+    const spec = restf.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.len < 8) return data;
+    if (!std.mem.startsWith(u8, spec, "`body.")) return data;
+    if (!std.mem.endsWith(u8, spec, "`")) return data;
+    const inner = spec[6 .. spec.len - 1];
+    if (inner.len == 0) return data;
+    if (std.mem.indexOfScalar(u8, inner, '.') != null) return data;
+    return h.jo(&.{.{ inner, data }});
+}
+
+fn respond(ctx: *Context, status: i64, data: Value, extra: []const h.Pair) Value {
     const out = h.jo(&.{
         .{ "status", h.vnum(status) },
         .{ "statusText", h.vstr("OK") },
-        .{ "json", h.json_thunk(data) },
+        .{ "json", h.json_thunk(envelope(ctx, data)) },
         .{ "body", h.vstr("not-used") },
     });
     for (extra) |kv| h.setp(out, kv[0], kv[1]);
@@ -182,20 +209,20 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
         const found = vs.select(h.A(), entmap, args) catch h.olist();
         const ent = h.get_elem(found, h.vnum(0), h.vnull());
         if (h.is_noval(ent)) {
-            return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
+            return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         h.del_prop(ent, h.vstr("$KEY"));
-        return respond(200, h.clone(ent), &.{});
+        return respond(ctx, 200, h.clone(ent), &.{});
     } else if (std.mem.eql(u8, op.name, "list")) {
         const args = build_args(ctx, ctx.reqmatch);
         const found = vs.select(h.A(), entmap, args) catch h.olist();
         if (h.is_noval(found)) {
-            return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
+            return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         if (found == .array) {
             for (found.array.data.items) |item| h.del_prop(item, h.vstr("$KEY"));
         }
-        return respond(200, h.clone(found), &.{});
+        return respond(ctx, 200, h.clone(found), &.{});
     } else if (std.mem.eql(u8, op.name, "update")) {
         const reqdata = ctx.reqdata;
         var update_match = h.omap();
@@ -221,14 +248,14 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             }
         }
         if (h.is_noval(ent)) {
-            return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
+            return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         if (ent == .object and reqdata == .object) {
             var it = reqdata.object.iterator();
             while (it.next()) |kv| h.setp(ent, kv.key_ptr.*, kv.value_ptr.*);
         }
         h.del_prop(ent, h.vstr("$KEY"));
-        return respond(200, h.clone(ent), &.{});
+        return respond(ctx, 200, h.clone(ent), &.{});
     } else if (std.mem.eql(u8, op.name, "remove")) {
         const m = resolve_match(ctx, ctx.reqmatch);
         const args = build_args(ctx, m);
@@ -238,7 +265,7 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             const id = h.getp(ent, "id");
             h.del_prop(entmap, id);
         }
-        return respond(200, h.vnull(), &.{});
+        return respond(ctx, 200, h.vnull(), &.{});
     } else if (std.mem.eql(u8, op.name, "create")) {
         _ = build_args(ctx, ctx.reqdata);
         var id = ctx.util().param(ctx, h.vstr("id"));
@@ -255,12 +282,12 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             h.setp(ent, "id", id);
             if (id == .string) h.setp(entmap, id.string, ent);
             h.del_prop(ent, h.vstr("$KEY"));
-            return respond(200, h.clone(ent), &.{});
+            return respond(ctx, 200, h.clone(ent), &.{});
         }
-        return respond(200, ent, &.{});
+        return respond(ctx, 200, ent, &.{});
     }
 
-    return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Unknown operation") }});
+    return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Unknown operation") }});
 }
 
 // make_netsim (test-local): counter-driven latency / first-N failures /

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "provides": {
     "target": [
       "c",