@voxgig/sdkgen 4.8.3 → 4.10.0

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 }});

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

@@ -150,12 +150,12 @@ pub const Collector = struct {
 
     fn call(p: *anyopaque, _: std.mem.Allocator, arg: Value) anyerror!Value {
         const self: *Collector = @ptrCast(@alignCast(p));
-        self.items.append(arg) catch {};
+        self.items.append(h.A(), arg) catch {};
         return vnull();
     }
     pub fn new() *Collector {
         const s = h.A().create(Collector) catch unreachable;
-        s.* = .{ .items = std.ArrayList(Value).init(h.A()) };
+        s.* = .{ .items = .empty };
         return s;
     }
     pub fn fn_val(self: *Collector) Value {
@@ -205,7 +205,7 @@ pub const Recorder = struct {
 
     fn call(p: *anyopaque, opctx: *Context, url: []const u8, fetchdef: Value) E!Value {
         const self: *Recorder = @ptrCast(@alignCast(p));
-        self.calls.append(h.jo(&.{
+        self.calls.append(h.A(), h.jo(&.{
             .{ "url", h.vstr(url) },
             .{ "fetchdef", fetchdef },
         })) catch {};
@@ -218,7 +218,7 @@ pub const Recorder = struct {
     }
     pub fn new(reply: ?ReplyFn) *Recorder {
         const s = h.A().create(Recorder) catch unreachable;
-        s.* = .{ .calls = std.ArrayList(Value).init(h.A()), .reply = reply };
+        s.* = .{ .calls = .empty, .reply = reply };
         return s;
     }
     pub fn fetcher(self: *Recorder) Fetcher {
@@ -326,19 +326,19 @@ fn strLess(_: void, a: []const u8, b: []const u8) bool {
 fn fhBuildUrl(spec: *sdk.Spec) []const u8 {
     var url = std.fmt.allocPrint(h.A(), "{s}{s}", .{ spec.base, spec.path }) catch spec.path;
     if (spec.query == .object) {
-        var keys = std.ArrayList([]const u8).init(h.A());
+        var keys: std.ArrayList([]const u8) = .empty;
         var it = spec.query.object.iterator();
         while (it.next()) |kv| {
-            if (!h.is_noval(kv.value_ptr.*)) keys.append(kv.key_ptr.*) catch {};
+            if (!h.is_noval(kv.value_ptr.*)) keys.append(h.A(), kv.key_ptr.*) catch {};
         }
         if (keys.items.len != 0) {
             std.mem.sort([]const u8, keys.items, {}, strLess);
-            var qs = std.ArrayList(u8).init(h.A());
+            var qs: std.ArrayList(u8) = .empty;
             for (keys.items) |k| {
-                if (qs.items.len != 0) qs.append('&') catch {};
+                if (qs.items.len != 0) qs.append(h.A(), '&') catch {};
                 const v = h.getp(spec.query, k);
                 const part = std.fmt.allocPrint(h.A(), "{s}={s}", .{ h.esc_url(k), h.esc_url(h.scalar_str(v)) }) catch "";
-                qs.appendSlice(part) catch {};
+                qs.appendSlice(h.A(), part) catch {};
             }
             url = std.fmt.allocPrint(h.A(), "{s}?{s}", .{ url, qs.items }) catch url;
         }
@@ -520,7 +520,7 @@ pub fn fh_make(server: ?Fetcher, feats: []const FeatSpec) *FhHarness {
             while (it.next()) |kv| h.setp(fopts, kv.key_ptr.*, kv.value_ptr.*);
         }
         fs.feat.callInit(rootctx, fopts);
-        client.features.append(fs.feat) catch {};
+        client.features.append(h.A(), fs.feat) catch {};
     }
 
     utility.feature_hook(rootctx, "PostConstruct");

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

@@ -37,15 +37,15 @@ fn makeAlwaysOk() Value {
 }
 
 // A deterministic sleep recorder: appends each requested ms to `sleep_log`.
-var sleep_log: std.ArrayList(i64) = undefined;
+var sleep_log: std.ArrayList(i64) = .empty;
 var sleep_log_init = false;
 var sleep_dummy: u8 = 0;
 fn sleepRecCall(_: *anyopaque, _: std.mem.Allocator, arg: Value) anyerror!Value {
     if (!sleep_log_init) {
-        sleep_log = std.ArrayList(i64).init(h.A());
+        sleep_log = .empty;
         sleep_log_init = true;
     }
-    sleep_log.append(h.to_int(arg)) catch {};
+    sleep_log.append(h.A(), h.to_int(arg)) catch {};
     return vnull();
 }
 fn sleepRec() Value {
@@ -200,7 +200,7 @@ test "gotcha6: netsim conn error code" {
 test "gotcha6: netsim seeded latency is deterministic" {
     const mk = struct {
         fn build() []const i64 {
-            sleep_log = std.ArrayList(i64).init(h.A());
+            sleep_log = .empty;
             sleep_log_init = true;
             const opts = h.jo(&.{
                 .{ "feature", h.jo(&.{.{ "netsim", h.jo(&.{
@@ -217,7 +217,7 @@ test "gotcha6: netsim seeded latency is deterministic" {
             while (i < 4) : (i += 1) {
                 _ = client.sdkUtility.fetch(ctx, "http://x", h.jo(&.{.{ "url", h.vstr("http://x") }})) catch {};
             }
-            return sleep_log.toOwnedSlice() catch &.{};
+            return sleep_log.toOwnedSlice(h.A()) catch &.{};
         }
     };
     const run1 = mk.build();