@voxgig/sdkgen 4.0.0 → 4.1.0

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/py/test/test_struct_utility.py

@@ -516,7 +516,7 @@ class TestStructUtility(unittest.TestCase):
 
     # -------------------------------------------------
     # transform tests
-    # Inputs and expected outputs: build/test/transform.aontu
+    # Inputs and expected outputs: build/test/transform.aon
     # -------------------------------------------------
 
     def test_transform_basic(self):

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/rust/tests/common/mod.rs

@@ -292,7 +292,7 @@ pub fn match_deep(check: &Value, base: &Value) -> Option<String> {
 // ---- runset (mirrors go runner_test.go runset) -----------------------------------
 
 // Sections deliberately left empty in the shared corpus
-// (.sdk/test/primary/<name>.aontu carries a PENDING header). Everything else
+// (.sdk/test/primary/<name>.aon carries a PENDING header). Everything else
 // MUST contribute cases.
 pub const PENDING_SECTIONS: &[&str] = &[
     "fetcher", "makeFetchDef", "makeResult", "featureAdd",

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/ts/test/utility/Corpus.test.ts

@@ -16,7 +16,7 @@ import { TEST_JSON_FILE } from './index'
 // indistinguishable from a fixture that passes.
 //
 // Deferral is therefore DATA (`basic.pending`), not a comment: comments do not
-// survive compilation to test.json, so a marker written only in the .aontu
+// survive compilation to test.json, so a marker written only in the .aon
 // source cannot be checked by the thing that consumes it. Being data, these
 // invariants hold for every port, not just this one.
 describe('Corpus', () => {
@@ -44,7 +44,7 @@ describe('Corpus', () => {
     })
     equal(undeclared.join(','), '',
       'these sections compile to ZERO cases and carry no `basic: pending` ' +
-      'reason — add cases, or state the blocker in .sdk/test/primary/<name>.aontu')
+      'reason — add cases, or state the blocker in .sdk/test/primary/<name>.aon')
   })
 
 

package/project/.sdk/tm/ts/test/utility/PrimaryUtility.test.ts

@@ -32,7 +32,7 @@ describe('PrimaryUtility', async () => {
 
 
   // Sections deliberately left empty in the shared corpus
-  // (.sdk/test/primary/<name>.aontu carries a PENDING header). Everything
+  // (.sdk/test/primary/<name>.aon carries a PENDING header). Everything
   // else MUST contribute cases.
   const PENDING = new Set([
     'fetcher', 'makeFetchDef', 'makeResult',

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.0",
+  "version": "4.1.0",
   "provides": {
     "target": [
       "c",