@voxgig/sdkgen 4.0.1 → 4.2.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.2.0'
 const KONSOLE = console
 
 

package/package.json

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

package/project/.sdk/src/cmp/scala/TestDirect_scala.ts

@@ -118,7 +118,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
 import java.util.{ArrayList, LinkedHashMap, List => JList, Map => JMap}
 import java.util.function.{BiFunction, Supplier}
 
-import ${scalapackage}.core.{Helpers, ${SDK}}
+import ${scalapackage}.core.{Helpers, SdkEntity, ${SDK}}
 
 object ${EntityName}DirectTest {
 

package/project/.sdk/src/cmp/scala/TestEntity_scala.ts

@@ -90,7 +90,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
 import java.util.{ArrayList, LinkedHashMap, List => JList, Map => JMap}
 
-import ${scalapackage}.core.{Helpers, ${SDK}}
+import ${scalapackage}.core.{Helpers, SdkEntity, ${SDK}}
 import ${scalapackage}.utility.struct.Struct
 
 object ${EntityName}EntityTest {

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/clojure/src/sdk/features.clj

@@ -104,9 +104,27 @@
                                  val))
                (let [test-fetcher
                      (fn [fctx _fullurl _fetchdef]
-                       (let [respond (fn [status data extra]
-                                       (let [out (vs/jm "status" status "statusText" "OK"
-                                                        "json" (fn [] data) "body" "not-used")]
+                       ;; 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. `fctx` is in
+                       ;; scope here, so the point is the one being served.
+                       (let [envelope (fn [data]
+                                        (let [tm (vs/getprop (core/oget fctx :point) "transform")
+                                              spec (vs/getprop tm "res")]
+                                          ;; Exactly `body.<key>`; a deeper path is not an
+                                          ;; envelope this mock can synthesise.
+                                          (if (and (some? data) (string? spec))
+                                            (if-let [m (re-matches #"`body\.([^`.]+)`" spec)]
+                                              (vs/jm (second m) data)
+                                              data)
+                                            data)))
+                             respond (fn [status data extra]
+                                       (let [payload (envelope data)
+                                             out (vs/jm "status" status "statusText" "OK"
+                                                        "json" (fn [] payload) "body" "not-used")]
                                          (when extra (doseq [item (or (vs/items extra) [])]
                                                        (.put ^java.util.Map out (vs/getprop item 0) (vs/getprop item 1))))
                                          [out nil]))

package/project/.sdk/tm/cpp/Makefile

@@ -10,6 +10,16 @@ CXXFLAGS ?= -std=c++17 -O0 -g -Wall -Wextra -Wno-unused-parameter -pthread
 TEST_SRCS := $(wildcard test/*.cpp)
 TEST_BINS := $(TEST_SRCS:.cpp=.out)
 
+# REBUILD WHEN A HEADER CHANGES. The runtime is header-only, so a test binary
+# depends on far more than its own .cpp — but the pattern rule below names
+# only that .cpp, so make happily reused a stale .out after every change to
+# core/, feature/, entity/ or utility/. A real fix to the mock transport read
+# as "still failing" through several rebuilds because the binary under test
+# predated it. Listing the headers is cheap and makes `make test` mean what it
+# says.
+SDK_HDRS := $(wildcard core/*.hpp entity/*.hpp feature/*.hpp \
+                       utility/*.hpp utility/*/*.hpp *.hpp)
+
 .PHONY: test build clean
 
 build: $(TEST_BINS)
@@ -23,7 +33,7 @@ test: build
 	if [ $$fail -ne 0 ]; then echo "SOME TESTS FAILED"; exit 1; fi; \
 	echo "ALL TESTS PASSED"
 
-test/%.out: test/%.cpp
+test/%.out: test/%.cpp $(SDK_HDRS)
 	$(CXX) $(CXXFLAGS) $< -o $@
 
 clean:

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/dart/lib/feature/test/TestFeature.dart

@@ -38,12 +38,40 @@ class TestFeature extends BaseFeature {
 
     final self = this;
 
-    dynamic respond(int status, [dynamic data, dynamic res]) {
+    // 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.
+    dynamic envelope(dynamic fctx, dynamic data) {
+      if (null == data || null == fctx || null == fctx.point) {
+        return data;
+      }
+      // dart wraps the point in a Point OBJECT (Context._aspoint), so its
+      // fields are typed properties, not map keys — vs.getprop on it returns
+      // null and the envelope silently never applies.
+      final tm = fctx.point.transform;
+      final spec = vs.getprop(tm, 'res');
+      if (spec is! 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.
+      final m = RegExp(r'^`body\.([^`.]+)`$').firstMatch(spec);
+      if (null == m) {
+        return data;
+      }
+      return <String, dynamic>{m.group(1)!: data};
+    }
+
+    dynamic respond(dynamic fctx, int status, [dynamic data, dynamic res]) {
+      final payload = envelope(fctx, data);
       final out = vs.merge([
         <String, dynamic>{
           'status': status,
           'statusText': 'OK',
-          'json': () => data,
+          'json': () => payload,
           'body': 'not-used',
         },
         vs.getdef(res, {}),
@@ -66,30 +94,30 @@ class TestFeature extends BaseFeature {
         final found = vs.select(entmap, args);
         final ent = vs.getelem(found, 0);
         if (null == ent) {
-          return respond(404, null, {'statusText': S_NOT_FOUND});
+          return respond(fctx, 404, null, {'statusText': S_NOT_FOUND});
         } else {
           vs.delprop(ent, r'$KEY');
           final out = vs.clone(ent);
-          return respond(200, out);
+          return respond(fctx, 200, out);
         }
       } else if ('list' == op.name) {
         final args = self.buildArgs(fctx, op, fctx.reqmatch);
         final found = vs.select(entmap, args);
         if (null == found) {
-          return respond(404, null, {'statusText': S_NOT_FOUND});
+          return respond(fctx, 404, null, {'statusText': S_NOT_FOUND});
         } else {
           for (final ent in found) {
             vs.delprop(ent, r'$KEY');
           }
           final out = vs.clone(found);
-          return respond(200, out);
+          return respond(fctx, 200, out);
         }
       } else if ('update' == op.name) {
         final args = self.buildArgs(fctx, op, fctx.reqdata);
         final found = vs.select(entmap, args);
         final ent = vs.getelem(found, 0);
         if (null == ent) {
-          return respond(404, null, {'statusText': S_NOT_FOUND});
+          return respond(fctx, 404, null, {'statusText': S_NOT_FOUND});
         } else {
           // Dart's single null stands in for the donor's undefined: merge
           // must not overwrite stored values with absent ones.
@@ -104,7 +132,7 @@ class TestFeature extends BaseFeature {
           vs.merge([ent, upddata]);
           vs.delprop(ent, r'$KEY');
           final out = vs.clone(ent);
-          return respond(200, out);
+          return respond(fctx, 200, out);
         }
       } else if ('remove' == op.name) {
         final args = self.buildArgs(fctx, op, fctx.reqmatch);
@@ -115,7 +143,7 @@ class TestFeature extends BaseFeature {
         if (null != ent) {
           vs.delprop(entmap, vs.getprop(ent, 'id'));
         }
-        return respond(200);
+        return respond(fctx, 200);
       } else if ('create' == op.name) {
         self.buildArgs(fctx, op, fctx.reqdata);
         dynamic id = param(fctx, 'id');
@@ -130,7 +158,7 @@ class TestFeature extends BaseFeature {
         vs.setprop(entmap, id, ent);
         vs.delprop(ent, r'$KEY');
         final out = vs.clone(ent);
-        return respond(200, out);
+        return respond(fctx, 200, out);
       }
 
       return 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
 
@@ -258,7 +285,7 @@ defmodule ProjectName.Feature.Test do
           netsleep.(pick_latency(net))
           status = H.or_(S.getprop(net, "failStatus"), 503)
 
-          respond(status, nil,
+          respond(fctx, status, nil,
             S.jm(["statusText", "Simulated Failure", "headers", S.jm([])]))
 
         true ->