tricu

reduce_test.zig (28013B)

---

 const std = @import("std");
 const testing = std.testing;
 const Arena = @import("arena.zig").Arena;
 const tree = @import("tree.zig");
 const machine = @import("reduce.zig");
 const codecs = @import("codecs.zig");
 
 fn stem(a: *Arena, x: u32) !u32 {
     return a.alloc(.{ .stem = .{ .child = x } });
 }
 fn fork(a: *Arena, x: u32, y: u32) !u32 {
     return a.alloc(.{ .fork = .{ .left = x, .right = y } });
 }
 fn app(a: *Arena, x: u32, y: u32) !u32 {
     return a.alloc(.{ .app = .{ .func = x, .arg = y } });
 }
 fn force(a: *Arena, x: u32) !u32 {
     return machine.reduce(x, a, 10_000_000);
 }
 fn equal(a: *Arena, x: u32, y: u32) !void {
     const nx = a.get(try force(a, x)).*;
     const ny = a.get(try force(a, y)).*;
     try testing.expectEqual(std.meta.activeTag(nx), std.meta.activeTag(ny));
     switch (nx) {
         .leaf => {},
         .stem => |s| try equal(a, s.child, ny.stem.child),
         .fork => |f| {
             try equal(a, f.left, ny.fork.left);
             try equal(a, f.right, ny.fork.right);
         },
         .app => unreachable,
     }
 }
 
 test "kernel rules, including lazy distribution and all triage arms" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const u = try stem(&a, t);
     const v = try fork(&a, u, t);
     try equal(&a, try app(&a, t, v), try stem(&a, v));
     try equal(&a, try app(&a, u, v), try fork(&a, t, v));
     try equal(&a, try app(&a, try fork(&a, t, v), u), v);
     const s = try fork(&a, try stem(&a, u), t);
     try equal(&a, try app(&a, s, v), try app(&a, try app(&a, u, v), try app(&a, t, v)));
     const f = try fork(&a, try fork(&a, v, u), t);
     try equal(&a, try app(&a, f, t), v);
     try equal(&a, try app(&a, f, u), try app(&a, u, t));
     try equal(&a, try app(&a, f, v), try app(&a, try app(&a, t, u), t));
 }
 
 test "discarded work and constructor children are never demanded" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const poison = try app(&a, t, t);
     a.get(poison).* = .{ .app = .{ .func = poison, .arg = t } };
     const k = try fork(&a, t, t);
     const result = try app(&a, k, poison);
     try testing.expectEqual(tree.NodeTag.leaf, std.meta.activeTag(a.get(try machine.reduce(result, &a, 1)).*));
     const constructor = try app(&a, t, poison);
     const r = try machine.reduce(constructor, &a, 1);
     try testing.expectEqual(poison, a.get(r).stem.child);
     try testing.expectError(error.FuelExhausted, machine.reduce(poison, &a, 100));
 }
 
 test "shared redex updated once and fuel failure can be resumed" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const shared = try app(&a, t, t);
     try testing.expectError(error.FuelExhausted, machine.reduce(shared, &a, 0));
     _ = try machine.reduce(shared, &a, 1);
     _ = try machine.reduce(shared, &a, 0);
     try testing.expectEqual(t, a.get(shared).stem.child);
 }
 
 test "100000 nested function demands and selected-result updates use heap frames" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const identity = try fork(&a, t, t);
     var x = t;
     for (0..100000) |_| x = try app(&a, try fork(&a, t, x), t);
     try testing.expect(a.get(try force(&a, x)).* == .leaf);
     // Left-associated applications of a constant returning itself would be
     // cyclic; use alternating constructor applications and constant selection.
     x = identity;
     for (0..100000) |_| x = try app(&a, x, identity);
     _ = try force(&a, x);
 }
 
 test "non-moving collection preserves explicit roots and reuses dead slots" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const kept = try stem(&a, t);
     try a.roots.append(a.allocator, kept);
     for (0..1000) |_| _ = try fork(&a, t, t);
     const before = a.len();
     try a.collect(&.{});
     try testing.expectEqual(@as(usize, 0), a.free.items.len);
     for (0..1000) |_| _ = try stem(&a, t);
     try testing.expectEqual(before, a.len());
     try testing.expectEqual(t, a.get(kept).stem.child);
 }
 
 fn gcWorkload(allocator: std.mem.Allocator) !void {
     var a = Arena.init(allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const k = try stem(&a, t);
     const direct_id = try fork(&a, try stem(&a, k), k);
     // S (K K) I is extensionally K, but not a constructor shortcut. Keep
     // real distribution allocations here so GC/failure stress cannot disappear
     // when the direct S K b identity is fused by the evaluator.
     const extended_k = try fork(&a, try stem(&a, try fork(&a, t, k)), direct_id);
     const id = try fork(&a, try stem(&a, extended_k), k);
     var x = t;
     for (0..100) |_| x = try app(&a, id, x);
     a.gc_enabled = true;
     try a.setGcPolicy(8, 1);
     try testing.expect(a.get(try force(&a, x)).* == .leaf);
     try testing.expect(a.collections > 1);
     try a.collect(&.{x});
     try testing.expectEqual(@as(usize, a.len() - 1), a.free.items.len);
 }
 
 test "GC during distribution preserves pending demands" {
     try gcWorkload(testing.allocator);
 }
 
 test "allocation failures unwind machine and collector without leaking" {
     try testing.checkAllAllocationFailures(testing.allocator, gcWorkload, .{});
 }
 
 test "deep shared DAG copying uses a growable work stack" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     var b = Arena.init(testing.allocator);
     defer b.deinit();
     var x = try a.alloc(.leaf);
     for (0..10000) |_| x = try fork(&a, x, x);
     const copied = try tree.copyTree(a.nodes.items, &b, x);
     try testing.expectEqual(a.len(), b.len());
     try testing.expectEqual(b.get(copied).fork.left, b.get(copied).fork.right);
 }
 
 test "boolean observation forces its child and rejects malformed booleans" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const delayed = try app(&a, try fork(&a, t, t), t);
     try testing.expectEqual(true, (try codecs.toBool(&a, try stem(&a, delayed))).?);
     try testing.expectEqual(@as(?bool, null), try codecs.toBool(&a, try stem(&a, try stem(&a, t))));
 }
 
 const handles = @import("handles.zig");
 fn handleWorkload(allocator: std.mem.Allocator) !void {
     var a = Arena.init(allocator);
     defer a.deinit();
     var table: handles.Table = .{};
     defer table.deinit(allocator);
     const t = try a.alloc(.leaf);
     const handle = try table.create(allocator, t);
     try table.release(handle);
     const replacement = try table.create(allocator, t);
     try testing.expectError(error.InvalidHandle, table.get(handle));
     try testing.expectEqual(t, try table.get(replacement));
     for (0..1000) |_| {
         const node = try stem(&a, t);
         const h = try table.create(allocator, node);
         try table.release(h);
     }
     a.roots.clearRetainingCapacity();
     try table.appendRoots(&a);
     try a.collect(&.{});
     try testing.expectEqual(@as(usize, 0), a.free.items.len);
     try testing.expectEqual(@as(usize, 2), table.slots.items.len);
 }
 
 test "handle table failure cleanup and reclamation" {
     try testing.checkAllAllocationFailures(testing.allocator, handleWorkload, .{});
 }
 
 // Independent eager reference on finite, already-normal inputs. No application
 // nodes, mutation or continuation/update machinery are shared with the machine.
 fn reference(a: *Arena, f: u32, x: u32, fuel: *usize) error{ OutOfMemory, FuelExhausted }!u32 {
     if (fuel.* == 0) return error.FuelExhausted;
     fuel.* -= 1;
     return switch (a.get(f).*) {
         .leaf => stem(a, x),
         .stem => |s| fork(a, s.child, x),
         .fork => |b| switch (a.get(b.left).*) {
             .leaf => b.right,
             .stem => |s| reference(a, try reference(a, s.child, x, fuel), try reference(a, b.right, x, fuel), fuel),
             .fork => |branches| switch (a.get(x).*) {
                 .leaf => branches.left,
                 .stem => |s| reference(a, branches.right, s.child, fuel),
                 .fork => |arg| reference(a, try reference(a, b.right, arg.left, fuel), arg.right, fuel),
                 .app => unreachable,
             },
             .app => unreachable,
         },
         .app => unreachable,
     };
 }
 
 test "all pairs of depth-two values agree with an independent reference" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const small = [_]u32{ t, try stem(&a, t), try fork(&a, t, t) };
     var values: std.ArrayList(u32) = .empty;
     defer values.deinit(a.allocator);
     try values.append(a.allocator, t);
     for (small) |x| {
         try values.append(a.allocator, try stem(&a, x));
         for (small) |y| try values.append(a.allocator, try fork(&a, x, y));
     }
     for (values.items) |f| for (values.items) |x| {
         var fuel: usize = 10000;
         const expected = try reference(&a, f, x, &fuel);
         try equal(&a, try app(&a, f, x), expected);
         try equal(&a, try machine.reduceUnbounded(try app(&a, f, x), &a), expected);
     };
 }
 
 test "result tags are demanded booleans, not arbitrary non-true error tags" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const delayed = try app(&a, try fork(&a, t, t), t);
     const payload = try fork(&a, t, t);
     const good = try fork(&a, try stem(&a, delayed), payload);
     try testing.expect((try codecs.unwrapResult(&a, good)).?.ok);
     const malformed = try fork(&a, try fork(&a, t, t), payload);
     try testing.expectEqual(@as(?codecs.UnwrapResult, null), try codecs.unwrapResult(&a, malformed));
 }
 
 test "oversized host numbers return a decode failure rather than trapping" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const max = try codecs.ofNumber(&a, std.math.maxInt(u64));
     try testing.expectEqual(std.math.maxInt(u64), (try codecs.toNumber(&a, max)).?);
     const overflow = try fork(&a, try a.alloc(.leaf), max);
     try testing.expectEqual(@as(?u64, null), try codecs.toNumber(&a, overflow));
 }
 
 test "headroom policy can shrink after a live peak and rejects zero atomically" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     try a.setGcPolicy(8, 4);
     var root = try a.alloc(.leaf);
     for (0..100) |_| root = try stem(&a, root);
     try a.collect(&.{root});
     try testing.expectEqual(@as(usize, 404), a.gc_interval);
     try testing.expectError(error.InvalidData, a.setGcPolicy(0, 2));
     try testing.expectError(error.InvalidData, a.setGcPolicy(2, 0));
     try testing.expectEqual(@as(usize, 8), a.gc_min_interval);
     try testing.expectEqual(@as(usize, 4), a.gc_live_multiplier);
     try testing.expectEqual(@as(usize, 404), a.gc_interval);
     a.get(root).* = .leaf;
     try a.collect(&.{root});
     try testing.expectEqual(@as(usize, 8), a.gc_interval);
     try a.setGcPolicy(1, std.math.maxInt(usize));
     try testing.expectEqual(std.math.maxInt(usize), a.gc_interval);
     // Two live nodes exercise saturating multiplication, including on 32-bit.
     const next = try stem(&a, root);
     try a.collect(&.{next});
     try testing.expectEqual(std.math.maxInt(usize), a.gc_interval);
 }
 
 test "collection trims only dead tails and reuses interior holes without moving roots" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const hole = try stem(&a, t);
     const root = try fork(&a, t, t);
     for (0..1000) |_| _ = try a.alloc(.leaf);
     const capacity = a.nodes.capacity;
     try a.collect(&.{root});
     try testing.expectEqual(root + 1, a.len());
     try testing.expectEqual(capacity, a.nodes.capacity);
     try testing.expectEqualSlices(u32, &.{hole}, a.free.items);
     try testing.expectEqual(hole, try a.alloc(.leaf));
     try testing.expectEqual(root + 1, try a.alloc(.leaf));
     try testing.expectEqual(t, a.get(root).fork.left);
     try a.collect(&.{});
     try testing.expectEqual(@as(u32, 0), a.len());
     try testing.expectEqual(@as(usize, 0), a.free.items.len);
     try testing.expectEqual(@as(u32, 0), try a.alloc(.leaf));
 }
 
 test "constructor fast return still honors collection with zero fuel" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const root = try stem(&a, t);
     for (0..1000) |_| _ = try a.alloc(.leaf);
     try a.setGcPolicy(1, 1);
     a.gc_enabled = true;
     try testing.expectEqual(root, try machine.reduce(root, &a, 0));
     try testing.expectEqual(@as(usize, 1), a.collections);
     try testing.expectEqual(t, a.get(root).stem.child);
     try testing.expectEqual(@as(u32, 2), a.len());
 }
 
 test "suspended demands preserve fuel boundaries and clear retained scratch on failure" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const delayed_function = try app(&a, t, t);
     const root = try app(&a, delayed_function, t);
     try testing.expectError(error.FuelExhausted, machine.reduce(root, &a, 1));
     try testing.expectEqual(@as(usize, 0), a.reduction_frames.items.len);
     try testing.expectEqual(@as(usize, 0), a.reduction_roots.items.len);
     try testing.expect(a.reduction_frames.capacity > 0);
     _ = try machine.reduce(root, &a, 2);
     try testing.expectEqual(t, a.get(root).fork.left);
     // A delayed discriminator and a divergent, discarded argument.
     const delayed_leaf = try app(&a, try fork(&a, t, t), t);
     const poison = try app(&a, t, t);
     a.get(poison).* = .{ .app = .{ .func = poison, .arg = t } };
     const selected = try app(&a, try fork(&a, delayed_leaf, t), poison);
     _ = try machine.reduce(selected, &a, 2);
     try testing.expect(a.get(selected).* == .leaf);
     // A delayed selected result takes a second application entry.
     const delayed_result = try app(&a, t, t);
     const select = try app(&a, try fork(&a, t, delayed_result), poison);
     try testing.expectError(error.FuelExhausted, machine.reduce(select, &a, 1));
     try testing.expectEqual(@as(usize, 0), a.reduction_frames.items.len);
     _ = try machine.reduce(select, &a, 2);
     try testing.expectEqual(t, a.get(select).stem.child);
     // Delayed triage argument, then the stem arm creates another application.
     const triage = try fork(&a, try fork(&a, t, t), t);
     const argument = try app(&a, t, t);
     const inspect = try app(&a, triage, argument);
     try testing.expectError(error.FuelExhausted, machine.reduce(inspect, &a, 2));
     _ = try machine.reduce(inspect, &a, 1);
     try testing.expectEqual(t, a.get(inspect).stem.child);
 }
 
 test "collector allocation failure is retryable without losing live nodes or free slots" {
     // Fail each allocation/growth in the first collection, then retry in the
     // same arena. This also exercises dirty marks/grey left by failed marking.
     for (0..12) |offset| {
         var failing = testing.FailingAllocator.init(testing.allocator, .{});
         var a = Arena.init(failing.allocator());
         defer a.deinit();
         const t = try a.alloc(.leaf);
         _ = try a.alloc(.leaf); // interior hole
         var root = t;
         // Traversing right leaves many left demands on the grey stack;
         // each stem also shares t, exercising mark-on-enqueue deduplication.
         for (0..100) |_| root = try fork(&a, try stem(&a, t), root);
         for (0..100) |_| _ = try a.alloc(.leaf);
         const before = a.len();
         failing.fail_index = failing.alloc_index + offset;
         failing.resize_fail_index = failing.resize_index;
         a.collect(&.{root}) catch |err| {
             try testing.expectEqual(error.OutOfMemory, err);
             try testing.expectEqual(before, a.len());
             try testing.expectEqual(@as(usize, 0), a.free.items.len);
             try testing.expectEqual(@as(usize, 0), a.collections);
         };
         failing.fail_index = std.math.maxInt(usize);
         failing.resize_fail_index = std.math.maxInt(usize);
         try a.collect(&.{root});
         try testing.expectEqual(@as(usize, 201), a.last_live);
         try testing.expectEqualSlices(u32, &.{1}, a.free.items);
         var cursor = root;
         for (0..100) |_| {
             try testing.expectEqual(t, a.get(a.get(cursor).fork.left).stem.child);
             cursor = a.get(cursor).fork.right;
         }
         try testing.expectEqual(t, cursor);
     }
 }
 
 test "continuation allocation failure returns reusable scratch and evaluation can resume" {
     var failing = testing.FailingAllocator.init(testing.allocator, .{});
     var a = Arena.init(failing.allocator());
     defer a.deinit();
     const t = try a.alloc(.leaf);
     var root = t;
     for (0..1000) |_| root = try app(&a, try fork(&a, t, root), t);
     failing.fail_index = failing.alloc_index + 1;
     failing.resize_fail_index = failing.resize_index;
     try testing.expectError(error.OutOfMemory, force(&a, root));
     try testing.expectEqual(@as(usize, 0), a.reduction_frames.items.len);
     try testing.expectEqual(@as(usize, 0), a.reduction_roots.items.len);
     failing.fail_index = std.math.maxInt(usize);
     failing.resize_fail_index = std.math.maxInt(usize);
     try testing.expect(a.get(try force(&a, root)).* == .leaf);
     try testing.expectEqual(@as(usize, 0), a.reduction_frames.items.len);
 }
 
 // Small recursive oracle: the literal unfused rules, with one fuel charge for
 // each application entry. Test inputs are shallow; this is not a runtime path.
 fn unfused(root: u32, a: *Arena, fuel: *u64) machine.ReduceError!u32 {
     const node = a.get(root).*;
     if (node != .app) return root;
     if (fuel.* == 0) return error.FuelExhausted;
     fuel.* -= 1;
     const function = a.get(try unfused(node.app.func, a, fuel)).*;
     switch (function) {
         .leaf => a.get(root).* = .{ .stem = .{ .child = node.app.arg } },
         .stem => |s| a.get(root).* = .{ .fork = .{ .left = s.child, .right = node.app.arg } },
         .fork => |f| {
             const discriminator = a.get(try unfused(f.left, a, fuel)).*;
             switch (discriminator) {
                 .leaf => {
                     const value = try unfused(f.right, a, fuel);
                     a.get(root).* = a.get(value).*;
                 },
                 .stem => |s| {
                     const left = try app(a, s.child, node.app.arg);
                     const right = try app(a, f.right, node.app.arg);
                     a.get(root).* = .{ .app = .{ .func = left, .arg = right } };
                     return unfused(root, a, fuel);
                 },
                 .fork => |branches| {
                     const argument = a.get(try unfused(node.app.arg, a, fuel)).*;
                     switch (argument) {
                         .leaf => {
                             const value = try unfused(branches.left, a, fuel);
                             a.get(root).* = a.get(value).*;
                         },
                         .stem => |s| {
                             a.get(root).* = .{ .app = .{ .func = branches.right, .arg = s.child } };
                             return unfused(root, a, fuel);
                         },
                         .fork => |v| {
                             const inner = try app(a, f.right, v.left);
                             a.get(root).* = .{ .app = .{ .func = inner, .arg = v.right } };
                             return unfused(root, a, fuel);
                         },
                         .app => unreachable,
                     }
                 },
                 .app => unreachable,
             }
         },
         .app => unreachable,
     }
     return root;
 }
 
 fn equalUnfused(a: *Arena, x: u32, b: *Arena, y: u32) !void {
     var fuel: u64 = 10000;
     const expected = a.get(try unfused(x, a, &fuel)).*;
     const actual = b.get(try machine.reduce(y, b, 10000)).*;
     try testing.expectEqual(std.meta.activeTag(expected), std.meta.activeTag(actual));
     switch (expected) {
         .leaf => {},
         .stem => |s| try equalUnfused(a, s.child, b, actual.stem.child),
         .fork => |f| {
             try equalUnfused(a, f.left, b, actual.fork.left);
             try equalUnfused(a, f.right, b, actual.fork.right);
         },
         .app => unreachable,
     }
 }
 
 fn fusionFixture(a: *Arena, variant: usize, argument: usize, triage: bool) !u32 {
     const t = try a.alloc(.leaf);
     const k = try stem(a, t);
     const payload = try fork(a, k, t);
     const value = switch (variant) {
         0 => t,
         1 => k,
         2 => try fork(a, t, t),
         3 => try fork(a, t, k),
         4 => try fork(a, t, try fork(a, t, payload)),
         5 => try fork(a, t, try app(a, try fork(a, t, k), t)),
         // Negative controls: delayed discriminator, non-K stem, non-K fork.
         6 => try fork(a, try app(a, try fork(a, t, t), t), k),
         7 => try stem(a, k),
         8 => try fork(a, t, try fork(a, k, t)),
         else => unreachable,
     };
     const x = switch (argument) {
         0 => t,
         1 => k,
         2 => payload,
         3 => try app(a, try fork(a, t, payload), t),
         else => unreachable,
     };
     if (triage) {
         const pair = try fork(a, x, k);
         const input = if (argument == 3) try app(a, try fork(a, t, pair), t) else pair;
         return app(a, try fork(a, try fork(a, k, t), value), input);
     }
     return app(a, try fork(a, try stem(a, value), t), x);
 }
 
 test "fused distribution and triage agree with literal rules at every small fuel boundary" {
     for ([_]bool{ false, true }) |triage| for (0..9) |variant| for (0..4) |argument| for (0..20) |budget| {
         var expected = Arena.init(testing.allocator);
         defer expected.deinit();
         var actual = Arena.init(testing.allocator);
         defer actual.deinit();
         const x = try fusionFixture(&expected, variant, argument, triage);
         const y = try fusionFixture(&actual, variant, argument, triage);
         var fuel: u64 = budget;
         const reference_result = unfused(x, &expected, &fuel);
         if (reference_result) |_| {
             _ = try machine.reduce(y, &actual, budget);
             try equalUnfused(&expected, x, &actual, y);
         } else |err| {
             try testing.expectEqual(error.FuelExhausted, err);
             try testing.expectError(error.FuelExhausted, machine.reduce(y, &actual, budget));
             // Partial graph shapes can differ; both must remain resumable.
             try equalUnfused(&expected, x, &actual, y);
         }
     };
 }
 
 test "fused identity and constant selection discard divergent branches" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const poison = try app(&a, t, t);
     a.get(poison).* = .{ .app = .{ .func = poison, .arg = poison } };
     const k = try stem(&a, t);
     const identity = try fork(&a, try stem(&a, k), poison);
     const result = try app(&a, identity, t);
     const before = a.allocations;
     _ = try machine.reduce(result, &a, 3);
     try testing.expect(a.get(result).* == .leaf);
     try testing.expectEqual(before, a.allocations);
     const constant = try fork(&a, try stem(&a, try fork(&a, t, try fork(&a, t, k))), poison);
     const discard = try app(&a, constant, poison);
     const allocated = a.allocations;
     _ = try machine.reduce(discard, &a, 3);
     try testing.expectEqual(t, a.get(discard).stem.child);
     try testing.expectEqual(allocated, a.allocations);
     // Selecting divergence must still demand it, rather than return a thunk.
     const demand = try app(&a, identity, poison);
     try testing.expectError(error.FuelExhausted, machine.reduce(demand, &a, 100));
 }
 
 test "fused selection updates shared demanded payloads and survives collection" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const payload = try app(&a, try fork(&a, t, t), t);
     const poison = try app(&a, t, t);
     a.get(poison).* = .{ .app = .{ .func = poison, .arg = poison } };
     const constant = try fork(&a, t, try fork(&a, t, payload));
     const root = try app(&a, try fork(&a, try stem(&a, constant), poison), poison);
     try a.roots.append(a.allocator, payload); // independently retained alias
     a.gc_enabled = true;
     try a.setGcPolicy(1, 1);
     _ = try machine.reduce(root, &a, 4);
     try testing.expect(a.get(root).* == .leaf);
     try testing.expect(a.get(payload).* == .leaf);
     try a.collect(&.{root});
     try testing.expect(a.get(root).* == .leaf);
     try testing.expect(a.get(payload).* == .leaf);
 }
 
 test "scalar application allocation initializes dirty recycled slots completely" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const hole = try app(&a, t, t);
     a.get(hole).* = .{ .app = .{ .func = hole, .arg = hole } };
     const kept = try stem(&a, t);
     try a.collect(&.{kept});
     try testing.expectEqual(hole, try a.allocApp(kept, t));
     try testing.expectEqual(kept, a.get(hole).app.func);
     try testing.expectEqual(t, a.get(hole).app.arg);
     _ = try machine.reduce(hole, &a, 1);
     try testing.expectEqual(t, a.get(hole).fork.left);
     try testing.expectEqual(t, a.get(hole).fork.right);
     try a.collect(&.{kept});
     try testing.expectEqual(hole, try a.alloc(.leaf));
     try testing.expect(a.get(hole).* == .leaf);
 }
 
 test "fused triage preserves lazy children and shared updates with forced GC" {
     for ([_]bool{ false, true }) |gc| for (0..5) |variant| {
         var a = Arena.init(testing.allocator);
         defer a.deinit();
         const t = try a.alloc(.leaf);
         const k = try stem(&a, t);
         const poison = try app(&a, t, t);
         a.get(poison).* = .{ .app = .{ .func = poison, .arg = poison } };
         const payload = try app(&a, try fork(&a, t, t), t);
         const handler = switch (variant) {
             0 => t,
             1 => k,
             2 => try fork(&a, t, t),
             3 => try fork(&a, t, k),
             4 => try fork(&a, t, try fork(&a, t, payload)),
             else => unreachable,
         };
         const left = if (variant == 1) payload else poison;
         const pair = try fork(&a, left, poison);
         const root = try app(&a, try fork(&a, try fork(&a, poison, poison), handler), pair);
         try a.roots.append(a.allocator, payload);
         a.gc_enabled = gc;
         try a.setGcPolicy(1, 1);
         const before = a.allocations;
         _ = try machine.reduce(root, &a, if (variant == 1 or variant == 4) 4 else 3);
         if (gc) {
             try testing.expect(a.collections > 0);
             try a.collect(&.{root});
         } else try testing.expectEqual(before, a.allocations);
         switch (variant) {
             0 => {
                 try testing.expectEqual(poison, a.get(root).fork.left);
                 try testing.expectEqual(poison, a.get(root).fork.right);
             },
             1, 4 => {
                 try testing.expect(a.get(root).* == .leaf);
                 try testing.expect(a.get(payload).* == .leaf);
             },
             2 => try testing.expectEqual(poison, a.get(root).stem.child),
             3 => {
                 try testing.expect(a.get(a.get(root).fork.left).* == .leaf);
                 try testing.expectEqual(poison, a.get(root).fork.right);
             },
             else => unreachable,
         }
         if (variant != 1 and variant != 4) try testing.expect(a.get(payload).* == .app);
     };
 }
 
 test "fused triage still demands a selected divergent child" {
     var a = Arena.init(testing.allocator);
     defer a.deinit();
     const t = try a.alloc(.leaf);
     const poison = try app(&a, t, t);
     a.get(poison).* = .{ .app = .{ .func = poison, .arg = poison } };
     const handler = try stem(&a, t);
     const root = try app(&a, try fork(&a, try fork(&a, t, t), handler), try fork(&a, poison, t));
     a.gc_enabled = true;
     try a.setGcPolicy(1, 1);
     try testing.expectError(error.FuelExhausted, machine.reduce(root, &a, 100));
     try testing.expectError(error.FuelExhausted, machine.reduce(root, &a, 100));
 }