@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/ts/test/vendor/omni/index.ts

@@ -1,5 +1,5 @@
-// VENDORED: @voxgig/omni 0.1.2 (typescript/src/index.ts)
-// Source: https://github.com/voxgig/omni @ 5956cc4e5ecdaeebd11eab8bb4b9462dfc76e018
+// VENDORED: @voxgig/omni 0.1.4 (typescript/src/index.ts)
+// Source: https://github.com/voxgig/omni @ 274708cc2d12b21707d975543953f845f8444be0  [tag: sdk-20260907-0029-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 // @voxgig/omni - shared multi-language test runner.
 

package/project/.sdk/tm/zig/Makefile

@@ -9,6 +9,16 @@ build:
 # filter the output: if "N/N tests passed" with N==total, treat as success.
 # `--summary all` is required so the count is printed.
 #
+# THE SUMMARY IS PARSED IN TWO SPELLINGS. Older toolchains wrote the test
+# tally as "217/223 tests passed; 6 skipped"; 0.16 writes the annotations as
+# a parenthesised list instead - "217/223 tests passed (6 skipped)", and
+# "(6 skipped, 1 crashed)" when something did go wrong. Reading only the
+# semicolon form off 0.16 finds no skip count at all, so "passed + skipped"
+# falls short of "total" and the tolerance refuses a run that was in fact
+# clean - failing precisely when the teardown crash it exists for happens.
+# Both spellings are accepted below, and any "failed"/"crashed"/"timed out"
+# in that same annotation is a real failure, never a teardown crash.
+#
 # A TEST THAT DID NOT COMPILE IS NOT IN THE TALLY. The tolerance above is for a
 # crash AFTER the tests ran, and it must never cover a build that failed: a
 # compile error means those test binaries never ran, so they never reach
@@ -32,11 +42,15 @@ test:
 		echo "zig: compilation errors — not a teardown crash"; \
 		exit 1; \
 	fi; \
-	summary=$$(echo "$$out" | grep -oE '[0-9]+/[0-9]+ tests passed(; [0-9]+ skipped)?' | tail -1); \
+	summary=$$(echo "$$out" | grep -oE '[0-9]+/[0-9]+ tests passed( \([^)]*\))?(; [0-9]+ skipped)?' | tail -1); \
 	passed=$$(echo "$$summary" | sed -E 's#([0-9]+)/([0-9]+).*#\1#'); \
 	total=$$(echo "$$summary" | sed -E 's#([0-9]+)/([0-9]+).*#\2#'); \
 	skipped=$$(echo "$$summary" | grep -oE '[0-9]+ skipped' | grep -oE '[0-9]+'); \
 	[ -n "$$skipped" ] || skipped=0; \
+	if echo "$$summary" | grep -qE '[0-9]+ (failed|crashed|timed out)'; then \
+		echo "zig: $$summary — tests failed, so this is not a teardown crash"; \
+		exit 1; \
+	fi; \
 	if [ -n "$$passed" ] && [ "$$total" -gt 0 ] && [ $$((passed + skipped)) -eq "$$total" ]; then \
 		exit 0; \
 	fi; \

package/project/.sdk/tm/zig/build.zig

@@ -8,6 +8,10 @@ const std = @import("std");
 // exposed as the "voxgig-struct" module so the corpus runner can import it,
 // and the whole SDK is exposed as the "sdk" module (root: root.zig).
 //
+// TOOLCHAIN: zig 0.16. A test artifact takes a `root_module` rather than a
+// `root_source_file`, so each test file gets its own module built here with
+// the struct and sdk modules already imported.
+//
 // The Zig test framework can crash with signal 11 during cleanup *after* all
 // tests pass, due to *MapRef/*ListRef cross-references in arena teardown. The
 // Makefile filters the output: "N/N tests passed" with N==total is success.
@@ -22,6 +26,17 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    // The vendored @voxgig/omni port: the corpus test ENGINE, driven by
+    // test/omniresolver.zig. A MODULE, not a path import, for two reasons:
+    // omni.zig reaches its own regex.zig by path, so the pair must belong to
+    // exactly one module; and `@import("omni")` cannot then be confused with
+    // the resolver that adapts it.
+    const omni_mod = b.addModule("omni", .{
+        .root_source_file = b.path("test/vendor/omni/omni.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
     // The SDK module (root re-exports the public surface).
     const sdk_mod = b.addModule("sdk", .{
         .root_source_file = b.path("root.zig"),
@@ -32,7 +47,7 @@ pub fn build(b: *std.Build) void {
 
     const test_step = b.step("test", "Run all tests");
 
-    // Every test file: gets both the struct and sdk modules.
+    // Every test file: gets the struct, sdk and omni modules.
     const test_files = [_][]const u8{
         "test/struct_corpus.zig",
         "test/generated_test.zig",
@@ -40,17 +55,20 @@ pub fn build(b: *std.Build) void {
         "test/feature_test.zig",
         "test/primary_utility_test.zig",
         "test/gotcha_test.zig",
+        "test/omnismoke_test.zig",
     };
 
     for (test_files) |tf| {
-        // Skip test files that do not exist yet (during template dev).
-        const t = b.addTest(.{
+        const test_mod = b.createModule(.{
             .root_source_file = b.path(tf),
             .target = target,
             .optimize = optimize,
         });
-        t.root_module.addImport("voxgig-struct", struct_mod);
-        t.root_module.addImport("sdk", sdk_mod);
+        test_mod.addImport("voxgig-struct", struct_mod);
+        test_mod.addImport("sdk", sdk_mod);
+        test_mod.addImport("omni", omni_mod);
+
+        const t = b.addTest(.{ .root_module = test_mod });
         const run_t = b.addRunArtifact(t);
         run_t.has_side_effects = true;
         test_step.dependOn(&run_t.step);

package/project/.sdk/tm/zig/core/helpers.zig

@@ -19,6 +19,12 @@ pub fn A() Allocator {
     return mem.a();
 }
 
+// The SDK's process-global Io (0.16 routes clocks/sleep/env/file IO through
+// one). See core/mem.zig for why it is global rather than a parameter.
+pub fn IO() std.Io {
+    return mem.io();
+}
+
 // ---- constructors ------------------------------------------------------
 
 pub fn vstr(s: []const u8) Value {
@@ -249,33 +255,33 @@ pub fn veq(x: Value, y: Value) bool {
 // ---- key / item vectors (test feature convenience) ---------------------
 
 pub fn keysof_vec(v: Value) [][]const u8 {
-    var out = std.ArrayList([]const u8).init(A());
+    var out: std.ArrayList([]const u8) = .empty;
     if (v == .object) {
         var it = v.object.iterator();
-        while (it.next()) |kv| out.append(kv.key_ptr.*) catch {};
+        while (it.next()) |kv| out.append(A(), kv.key_ptr.*) catch {};
     }
-    return out.toOwnedSlice() catch &.{};
+    return out.toOwnedSlice(A()) catch &.{};
 }
 
 pub const KVpair = struct { k: []const u8, v: Value };
 
 pub fn items_vec(v: Value) []KVpair {
-    var out = std.ArrayList(KVpair).init(A());
+    var out: std.ArrayList(KVpair) = .empty;
     if (v == .object) {
         var it = v.object.iterator();
-        while (it.next()) |kv| out.append(.{ .k = kv.key_ptr.*, .v = kv.value_ptr.* }) catch {};
+        while (it.next()) |kv| out.append(A(), .{ .k = kv.key_ptr.*, .v = kv.value_ptr.* }) catch {};
     }
-    return out.toOwnedSlice() catch &.{};
+    return out.toOwnedSlice(A()) catch &.{};
 }
 
 // ---- clocks / rng ------------------------------------------------------
 
 pub fn now_ms() i64 {
-    return std.time.milliTimestamp();
+    return std.Io.Clock.real.now(IO()).toMilliseconds();
 }
 
 pub fn sleep_ms(ms: i64) void {
-    if (ms > 0) std.time.sleep(@as(u64, @intCast(ms)) * std.time.ns_per_ms);
+    if (ms > 0) IO().sleep(.fromMilliseconds(ms), .awake) catch {};
 }
 
 var rand_seed: i64 = 123456789;
@@ -290,15 +296,50 @@ pub fn rand_int(n: i64) i64 {
 
 pub const CallFn = *const fn (ctx: *anyopaque, allocator: Allocator, arg: Value) anyerror!Value;
 
+// An SDK callable — an injected transport, clock, sleeper, id generator, a
+// custom utility, or a response body thunk — carries a captured context
+// pointer, because every one of them is created at run time over run-time
+// state. Zig has no closures, so the context travels beside the function.
+//
+// The struct port's `JsonFunc` is a bare `*const fn (Allocator) anyerror!Value`
+// with no context slot, so the BOX is what lives in the `.function` slot,
+// pointer-cast to fit. That is the same arrangement the SDK has always had:
+// the slot held `*const Callable` before too, and the type it is declared with
+// upstream is the only thing that changed. Every struct operation the SDK puts
+// callables through — clone, merge, validate, stringify, typify — treats the
+// slot as an opaque pointer and is unaffected.
+//
+// The one thing that must not happen is struct CALLING the slot as code. It
+// does that in exactly three places: a `getprop` whose `alt` is a function, a
+// single-segment `getpath` whose one part names a function held directly in
+// the store, and a `$`-prefixed validate command that is not built in and
+// resolves to a function in the store. The SDK reaches none of them — its
+// `getprop` alts are never functions, `h.getpath` is never called with a
+// one-segment path, and the validate store only ever holds `$TOP`/`$DTOP`-style
+// keys, all of which are built in. SDK code invokes its own callables through
+// `call_vfn`, never by letting struct resolve them.
+//
+// That was measured, not just reasoned: instrumenting all three sites in a
+// throwaway copy of the vendored file and running the whole suite records ONE
+// invocation, and it is the struct corpus's own `$FOO` handler — a real
+// context-free JsonFunc, which is what those sites are for.
+pub const Callable = struct {
+    ctx: *anyopaque,
+    call: CallFn,
+};
+
 pub fn callable(ctx_ptr: *anyopaque, f: CallFn) Value {
-    const c = A().create(vs.Callable) catch unreachable;
+    const c = A().create(Callable) catch unreachable;
     c.* = .{ .ctx = ctx_ptr, .call = f };
-    return .{ .function = c };
+    return .{ .function = @ptrCast(@alignCast(c)) };
 }
 
 pub fn call_vfn(f: Value, arg: Value) Value {
     return switch (f) {
-        .function => |c| c.call(c.ctx, A(), arg) catch vnull(),
+        .function => |fp| blk: {
+            const c: *const Callable = @ptrCast(@alignCast(fp));
+            break :blk c.call(c.ctx, A(), arg) catch vnull();
+        },
         else => vnull(),
     };
 }

package/project/.sdk/tm/zig/core/mem.zig

@@ -1,4 +1,4 @@
-// Process-global arena allocator for the SDK data model.
+// Process-global arena allocator and Io for the SDK data model.
 //
 // The SDK data model is the vendored voxgig struct Value (reference-stable
 // *MapRef / *ListRef nodes). Rust leans on a global allocator + Rc; Zig has
@@ -7,6 +7,14 @@
 // close to the Rust original and sidesteps the test allocator's leak checks
 // for SDK/struct data (tests still use testing.allocator for their own
 // bookkeeping). Mirrors struct/zig's per-run arena approach.
+//
+// Zig 0.16 routes clocks, sleeping, the environment and file IO through an
+// `std.Io` instance rather than free functions on `std.time` / `std.process` /
+// `std.fs`. An SDK cannot demand one from its caller without changing every
+// public signature, so — exactly as with the arena — one process-global
+// instance is used. `Io.Threaded.global_single_threaded` is the statically
+// initialised singleton std itself falls back to; it needs no allocator and no
+// deinit, and the startup code fills in its environment block.
 
 const std = @import("std");
 
@@ -18,3 +26,11 @@ pub fn a() std.mem.Allocator {
     }
     return arena.?.allocator();
 }
+
+pub fn threaded() *std.Io.Threaded {
+    return std.Io.Threaded.global_single_threaded;
+}
+
+pub fn io() std.Io {
+    return threaded().io();
+}

package/project/.sdk/tm/zig/core/utility.zig

@@ -252,11 +252,11 @@ pub fn feature_add_util(ctx: *Context, f: Feature) void {
             while (i < feats.items.len) : (i += 1) {
                 const nm = feats.items[i].name();
                 if (before.len != 0 and std.mem.eql(u8, before, nm)) {
-                    feats.insert(i, f) catch {};
+                    feats.insert(h.A(), i, f) catch {};
                     return;
                 }
                 if (after.len != 0 and std.mem.eql(u8, after, nm)) {
-                    feats.insert(i + 1, f) catch {};
+                    feats.insert(h.A(), i + 1, f) catch {};
                     return;
                 }
                 if (replace.len != 0 and std.mem.eql(u8, replace, nm)) {
@@ -266,14 +266,14 @@ pub fn feature_add_util(ctx: *Context, f: Feature) void {
             }
         }
     }
-    client.features.append(f) catch {};
+    client.features.append(h.A(), f) catch {};
 }
 
 pub fn feature_hook_util(ctx: *Context, name: []const u8) void {
     const client = ctx.client orelse return;
     // Snapshot so a hook that mutates the feature set is safe to iterate.
-    var snap = std.ArrayList(Feature).init(h.A());
-    for (client.features.items) |f| snap.append(f) catch {};
+    var snap: std.ArrayList(Feature) = .empty;
+    for (client.features.items) |f| snap.append(h.A(), f) catch {};
     for (snap.items) |f| f.dispatch(name, ctx);
 }
 
@@ -441,11 +441,11 @@ pub fn make_options_util(ctx: *Context) Value {
                     else => "SDK",
                 };
 
-                var out = std.ArrayList(u8).init(h.A());
+                var out: std.ArrayList(u8) = .empty;
                 var i: usize = 0;
                 while (i < base.len) {
                     if ('{' != base[i]) {
-                        out.append(base[i]) catch {};
+                        out.append(h.A(), base[i]) catch {};
                         i += 1;
                         continue;
                     }
@@ -454,7 +454,7 @@ pub fn make_options_util(ctx: *Context) Value {
                         j += 1;
                     }
                     if (j >= base.len or '}' != base[j] or j == i + 1) {
-                        out.append(base[i]) catch {};
+                        out.append(h.A(), base[i]) catch {};
                         i += 1;
                         continue;
                     }
@@ -465,8 +465,8 @@ pub fn make_options_util(ctx: *Context) Value {
                     };
                     if (0 == val.len) {
                         if (testmode) {
-                            out.appendSlice("test-") catch {};
-                            out.appendSlice(name) catch {};
+                            out.appendSlice(h.A(), "test-") catch {};
+                            out.appendSlice(h.A(), name) catch {};
                         } else {
                             std.debug.panic(
                                 "{s}: the server variable '{s}' is required: the API " ++
@@ -476,11 +476,11 @@ pub fn make_options_util(ctx: *Context) Value {
                             );
                         }
                     } else {
-                        out.appendSlice(val) catch {};
+                        out.appendSlice(h.A(), val) catch {};
                     }
                     i = j + 1;
                 }
-                h.setp(opts, "base", h.vstr(out.toOwnedSlice() catch base));
+                h.setp(opts, "base", h.vstr(out.toOwnedSlice(h.A()) catch base));
             }
         },
         else => {},
@@ -502,11 +502,11 @@ pub fn make_options_util(ctx: *Context) Value {
         else => "key,token,id",
     };
 
-    var parts = std.ArrayList([]const u8).init(h.A());
+    var parts: std.ArrayList([]const u8) = .empty;
     var it = std.mem.splitScalar(u8, clean_keys, ',');
     while (it.next()) |p| {
         const t = std.mem.trim(u8, p, " \t");
-        if (t.len != 0) parts.append(h.esc_re(t)) catch {};
+        if (t.len != 0) parts.append(h.A(), h.esc_re(t)) catch {};
     }
     const keyre = std.mem.join(h.A(), "|", parts.items) catch "";
 
@@ -516,9 +516,9 @@ pub fn make_options_util(ctx: *Context) Value {
     if (feature_order.array.data.items.len == 0) {
         const fmapv = h.getp(opts, "feature");
         if (fmapv == .object) {
-            var names = std.ArrayList([]const u8).init(h.A());
+            var names: std.ArrayList([]const u8) = .empty;
             var nit = fmapv.object.iterator();
-            while (nit.next()) |kv| names.append(kv.key_ptr.*) catch {};
+            while (nit.next()) |kv| names.append(h.A(), kv.key_ptr.*) catch {};
             std.mem.sort([]const u8, names.items, {}, mo_str_less);
             var has_test = false;
             for (names.items) |nm| {
@@ -1059,7 +1059,7 @@ pub fn prepare_headers_util(ctx: *Context) Value {
     if (h.is_noval(headers)) return h.omap();
 
     return switch (h.clone(headers)) {
-        .object => |_| h.clone(headers),
+        .object => h.clone(headers),
         else => h.omap(),
     };
 }
@@ -1420,7 +1420,10 @@ pub fn transform_request_util(ctx: *Context) Value {
     if (h.is_noval(reqform)) return ctx.reqdata;
 
     const store = h.jo(&.{.{ "reqdata", ctx.reqdata }});
-    return vs.transform(h.A(), store, reqform) catch ctx.reqdata;
+    // transform now reports collected injection errors beside the value; .out
+    // is what it used to return on its own, errors or not.
+    const tres = vs.transform(h.A(), store, reqform) catch return ctx.reqdata;
+    return tres.out;
 }
 
 pub fn transform_response_util(ctx: *Context) Value {
@@ -1449,7 +1452,8 @@ pub fn transform_response_util(ctx: *Context) Value {
         .{ "resmatch", res.resmatch },
     });
 
-    const resdata = vs.transform(h.A(), store, resform) catch return h.vnull();
+    const tres = vs.transform(h.A(), store, resform) catch return h.vnull();
+    const resdata = tres.out;
     res.resdata = resdata;
     return resdata;
 }

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

@@ -32,7 +32,7 @@ pub const AuditFeature = struct {
 
     pub fn make() Feature {
         const self = h.A().create(AuditFeature) catch unreachable;
-        self.* = .{ .records = std.ArrayList(Value).init(h.A()) };
+        self.* = .{ .records = .empty };
         return .{ .ptr = @ptrCast(self), .vtable = &vtable };
     }
 
@@ -73,7 +73,7 @@ pub const AuditFeature = struct {
         h.setp(record, "correlationId", h.vstr(ctx.id));
         if (ctx.result) |r| h.setp(record, "status", h.vnum(r.status));
 
-        self.records.append(record) catch {};
+        self.records.append(h.A(), record) catch {};
         const max: usize = @intCast(@max(sup.fopt_int(self.options, "max", 1000), 0));
         while (self.records.items.len > max) {
             _ = self.records.orderedRemove(0);

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

@@ -53,7 +53,7 @@ pub const CacheFeature = struct {
         const track = h.A().create(CacheTrack) catch unreachable;
         track.* = .{
             .store = std.StringHashMap(CacheEntry).init(h.A()),
-            .order = std.ArrayList([]const u8).init(h.A()),
+            .order = .empty,
         };
         self.* = .{ .track = track };
         return .{ .ptr = @ptrCast(self), .vtable = &vtable };
@@ -152,7 +152,7 @@ fn through(track: *CacheTrack, options: Value, ctx: *Context, url: []const u8, f
             const ttl = sup.fopt_int(options, "ttl", 5000);
             evict(track, options);
             track.store.put(key, .{ .expiry = now + ttl, .snapshot = snap }) catch {};
-            track.order.append(key) catch {};
+            track.order.append(h.A(), key) catch {};
             track.miss += 1;
             return replay(snap);
         }

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

@@ -38,7 +38,7 @@ pub const DebugFeature = struct {
 
     pub fn make() Feature {
         const self = h.A().create(DebugFeature) catch unreachable;
-        self.* = .{ .entries = std.ArrayList(Value).init(h.A()) };
+        self.* = .{ .entries = .empty };
         return .{ .ptr = @ptrCast(self), .vtable = &vtable };
     }
 
@@ -49,9 +49,9 @@ pub const DebugFeature = struct {
     fn redact(self: *DebugFeature, headers: Value) Value {
         const out = h.omap();
         const patterns: [][]const u8 = sup.fopt_str_list(self.options, "redact") orelse blk: {
-            var l = std.ArrayList([]const u8).init(h.A());
-            for (DEBUG_DEFAULT_REDACT) |p| l.append(p) catch {};
-            break :blk l.toOwnedSlice() catch &.{};
+            var l: std.ArrayList([]const u8) = .empty;
+            for (DEBUG_DEFAULT_REDACT) |p| l.append(h.A(), p) catch {};
+            break :blk l.toOwnedSlice(h.A()) catch &.{};
         };
         if (headers == .object) {
             var it = headers.object.iterator();
@@ -92,7 +92,7 @@ pub const DebugFeature = struct {
             if (ctx.result) |r| h.setp(entry, "status", h.vnum(r.status));
         }
 
-        self.entries.append(entry) catch {};
+        self.entries.append(h.A(), entry) catch {};
         const max: usize = @intCast(@max(sup.fopt_int(self.options, "max", 100), 0));
         while (self.entries.items.len > max) {
             _ = self.entries.orderedRemove(0);

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

@@ -33,7 +33,7 @@ pub const NetsimFeature = struct {
     pub fn make() Feature {
         const self = h.A().create(NetsimFeature) catch unreachable;
         const track = h.A().create(NetsimTrack) catch unreachable;
-        track.* = .{ .applied = std.ArrayList(Value).init(h.A()) };
+        track.* = .{ .applied = .empty };
         self.* = .{ .track = track };
         return .{ .ptr = @ptrCast(self), .vtable = &vtable };
     }
@@ -110,7 +110,7 @@ fn pick_latency(track: *NetsimTrack, options: Value) i64 {
 }
 
 fn track_applied(track: *NetsimTrack, ctx: *Context, applied: Value) void {
-    track.applied.append(applied) catch {};
+    track.applied.append(h.A(), applied) catch {};
     const calls = track.calls;
     const applied_list = h.olist();
     for (track.applied.items) |a| applied_list.array.append(a) catch {};

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

@@ -284,8 +284,8 @@ pub const PagingFeature = struct {
         // would send the caller back for a page that does not exist, forever.
         if (!explicit_more and (h.get_bool(paging, "hasMore") orelse false) != true and
             (!h.is_noval(h.getp(paging, "next")) or
-            !h.is_noval(h.getp(paging, "cursor")) or
-            !h.is_noval(h.getp(paging, "nextPage"))))
+                !h.is_noval(h.getp(paging, "cursor")) or
+                !h.is_noval(h.getp(paging, "nextPage"))))
         {
             h.setp(paging, "hasMore", h.vbool(true));
         }

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

@@ -9,6 +9,7 @@
 
 const std = @import("std");
 const h = @import("../core/helpers.zig");
+const mem = @import("../core/mem.zig");
 const err = @import("../core/error.zig");
 const types = @import("../core/types.zig");
 const sup = @import("support.zig");
@@ -65,22 +66,22 @@ pub const ProxyFeature = struct {
             if (no_proxy_opt == null) {
                 const np = first_env(&.{ "NO_PROXY", "no_proxy" });
                 if (np.len != 0) {
-                    var list = std.ArrayList([]const u8).init(h.A());
+                    var list: std.ArrayList([]const u8) = .empty;
                     var it = std.mem.splitScalar(u8, np, ',');
-                    while (it.next()) |s| list.append(s) catch {};
-                    no_proxy_opt = list.toOwnedSlice() catch null;
+                    while (it.next()) |s| list.append(h.A(), s) catch {};
+                    no_proxy_opt = list.toOwnedSlice(h.A()) catch null;
                 }
             }
         }
 
-        var np_list = std.ArrayList([]const u8).init(h.A());
+        var np_list: std.ArrayList([]const u8) = .empty;
         if (no_proxy_opt) |arr| {
             for (arr) |s| {
                 const trimmed = std.mem.trim(u8, s, " \t\r\n");
-                if (trimmed.len != 0) np_list.append(trimmed) catch {};
+                if (trimmed.len != 0) np_list.append(h.A(), trimmed) catch {};
             }
         }
-        const no_proxy: []const []const u8 = np_list.toOwnedSlice() catch &.{};
+        const no_proxy: []const []const u8 = np_list.toOwnedSlice(h.A()) catch &.{};
 
         self.track.url = url;
         self.track.no_proxy = no_proxy;
@@ -120,9 +121,15 @@ fn wrapCall(p: *anyopaque, ctx: *Context, url: []const u8, fetchdef: Value) err.
     return w.inner.invoke(ctx, url, routed);
 }
 
+// Zig 0.16 has no free-standing environment lookup: the block the process was
+// started with is owned by an Io implementation, and library code is expected
+// to be handed one. The SDK's Io is the process-global singleton (core/mem.zig),
+// and the startup code fills its environment block in, so that is where a
+// `fromEnv` proxy config reads HTTP(S)_PROXY / NO_PROXY from.
 fn first_env(names: []const []const u8) []const u8 {
+    const environ = mem.threaded().environ.process_environ;
     for (names) |name| {
-        if (std.process.getEnvVarOwned(h.A(), name)) |v| {
+        if (environ.getAlloc(h.A(), name)) |v| {
             if (v.len != 0) return v;
         } else |_| {}
     }
@@ -150,7 +157,7 @@ fn bypass(no_proxy: []const []const u8, url: []const u8) bool {
     const host = host_of(url);
     for (no_proxy) |np| {
         if (std.mem.eql(u8, np, "*")) return true;
-        const np_trim = std.mem.trimLeft(u8, np, ".");
+        const np_trim = std.mem.trimStart(u8, np, ".");
         if (std.mem.eql(u8, host, np)) return true;
         const suffix = std.fmt.allocPrint(h.A(), ".{s}", .{np_trim}) catch continue;
         if (std.mem.endsWith(u8, host, suffix)) return true;

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

@@ -105,7 +105,7 @@ fn iterate(options: Value, resdata: Value) []Value {
 
     const items: []const Value = if (resdata == .array) resdata.array.data.items else &[_]Value{};
 
-    var out = std.ArrayList(Value).init(h.A());
+    var out: std.ArrayList(Value) = .empty;
 
     if (chunk_size > 0) {
         const cs: usize = @intCast(chunk_size);
@@ -113,15 +113,15 @@ fn iterate(options: Value, resdata: Value) []Value {
         while (i < items.len) {
             if (chunk_delay > 0) sup.fopt_sleep(options, chunk_delay);
             const end = @min(i + cs, items.len);
-            out.append(h.ja(items[i..end])) catch {};
+            out.append(h.A(), h.ja(items[i..end])) catch {};
             i = end;
         }
-        return out.toOwnedSlice() catch &.{};
+        return out.toOwnedSlice(h.A()) catch &.{};
     }
 
     for (items) |item| {
         if (chunk_delay > 0) sup.fopt_sleep(options, chunk_delay);
-        out.append(item) catch {};
+        out.append(h.A(), item) catch {};
     }
-    return out.toOwnedSlice() catch &.{};
+    return out.toOwnedSlice(h.A()) catch &.{};
 }

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

@@ -56,11 +56,11 @@ pub fn fopt_list(options: Value, key: []const u8) Value {
 pub fn fopt_str_list(options: Value, key: []const u8) ?[][]const u8 {
     const l = h.getp(options, key);
     if (l != .array) return null;
-    var out = std.ArrayList([]const u8).init(h.A());
+    var out: std.ArrayList([]const u8) = .empty;
     for (l.array.data.items) |v| {
-        if (v == .string) out.append(v.string) catch {};
+        if (v == .string) out.append(h.A(), v.string) catch {};
     }
-    return out.toOwnedSlice() catch &.{};
+    return out.toOwnedSlice(h.A()) catch &.{};
 }
 
 // The injectable sleep (option "sleep": a function taking ms), defaulting to

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

@@ -33,7 +33,7 @@ pub const TelemetryFeature = struct {
 
     pub fn make() Feature {
         const self = h.A().create(TelemetryFeature) catch unreachable;
-        self.* = .{ .spans = std.ArrayList(Value).init(h.A()) };
+        self.* = .{ .spans = .empty };
         return .{ .ptr = @ptrCast(self), .vtable = &vtable };
     }
 
@@ -49,9 +49,9 @@ pub const TelemetryFeature = struct {
         }
         // Deterministic-ish sequential id; unique within a client instance.
         self.seq += 1;
-        var buf = std.ArrayList(u8).init(h.A());
-        buf.writer().print("{x:0>4}", .{@as(u64, @intCast(self.seq))}) catch {};
-        while (buf.items.len < 16) buf.append('0') catch {};
+        var buf: std.ArrayList(u8) = .empty;
+        buf.print(h.A(), "{x:0>4}", .{@as(u64, @intCast(self.seq))}) catch {};
+        while (buf.items.len < 16) buf.append(h.A(), '0') catch {};
         const prefix: []const u8 = if (std.mem.eql(u8, kind, "trace")) "t" else "s";
         return std.fmt.allocPrint(h.A(), "{s}{s}", .{ prefix, buf.items }) catch "";
     }
@@ -73,7 +73,7 @@ pub const TelemetryFeature = struct {
         h.setp(span, "ok", h.vbool(ok));
 
         self.active_spans -= 1;
-        self.spans.append(span) catch {};
+        self.spans.append(h.A(), span) catch {};
 
         const exporter = h.getp(self.options, "exporter");
         if (exporter == .function) {

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

@@ -153,11 +153,16 @@ fn build_args(ctx: *Context, args: Value) Value {
 
     const params_path = h.getpath(&.{ "args", "params" }, point);
     const reqd_params = vs.select(h.A(), params_path, h.jo(&.{.{ "reqd", h.vbool(true) }})) catch h.olist();
-    const reqd = vs.transform(h.A(), reqd_params, h.ja(&.{
-        h.vstr("`$EACH`"),
-        h.vstr(""),
-        h.vstr("`$KEY.name`"),
-    })) catch h.olist();
+    const reqd = blk: {
+        // transform now reports collected injection errors beside the value;
+        // .out is what it used to return on its own, errors or not.
+        const tres = vs.transform(h.A(), reqd_params, h.ja(&.{
+            h.vstr("`$EACH`"),
+            h.vstr(""),
+            h.vstr("`$KEY.name`"),
+        })) catch break :blk h.olist();
+        break :blk tres.out;
+    };
 
     const qand = h.olist();
     const q = h.jo(&.{.{ "`$AND`", qand }});