Fix apply on infinite lazy seq (F99)

applyFn now builds a lazy cons chain for variadic fn_val targets,
peeling off only fixed params and passing the rest as a seq.
A threadlocal flag signals VM/TreeWalk to use the seq directly
instead of re-wrapping it in a PersistentList.

Author: chaploud

.dev/checklist.md

@@ -16,7 +16,7 @@ Check at session start for items that become actionable.
 | ID   | Item                                        | Trigger                                                                  |
 |------|---------------------------------------------|--------------------------------------------------------------------------|
 | F94  | Upstream Alignment pass                     | ~38 UPSTREAM-DIFF markers remain — mostly permanent design diffs (protocol→fn, Java→Zig). No further alignment expected. |
-| F99  | Iterative lazy-seq realization engine       | D74 fixes sieve. General deep lazy-seq + apply-on-infinite still deferred. See `optimizations.md` |
+| F99  | Iterative lazy-seq realization engine       | D74 fixes sieve. apply-on-infinite fixed (lazy variadic path). Deep lazy-seq stack overflow still deferred. See `optimizations.md` |
 | F102 | map/filter chunked processing               | Chunked types exist, range is lazy. Optimization: use chunks in map/filter pipelines. |
 | F103 | Escape analysis (local scope skip GC)       | Compiler detects local-only Values, skip GC tracking                     |
 | F104 | Profile-guided optimization (extend IC)     | Extend inline caching beyond monomorphic                                 |

.dev/memo.md

@@ -29,20 +29,16 @@ Ready for next phase planning. See Task Queue below.
 
 ## Previous Task
 
-Phase 59: Deferred cleanup & test porting (ALL DONE).
-59.1: Ported Ratio upstream tests (ratio literals in add/sub/mul, i48 edge cases, BigInt/Ratio coercion).
-59.2: Ported promote ops tests (test-arbitrary-precision-subtract, defspec generative tests covered by CLJW-ADD).
-Also fixed: int/long/bigint/float coercion for Ratio/BigInt/BigDecimal types.
+F99 fix: apply on infinite lazy seq. Added lazy variadic path to applyFn
+(cons chain + peel fixed params, threadlocal flag for VM/TreeWalk rest packing).
 
 Previous:
 
-Phase 58: clojure.core.reducers (ALL DONE, 58.1-58.6).
-Post-phase: 3 bug fixes (parse-boolean, catch Error, walk+records),
-deferred/stale comment cleanup, record __reify_type filtering (seq/keys/vals/count).
+Phase 59: Deferred cleanup & test porting (ALL DONE).
+59.1-59.2: Ratio/promote ops upstream tests, coercion fixes.
 
 ## Known Issues
 
-- apply on infinite lazy seq realizes eagerly (F99 — apply doesn't pass rest args as seq)
 - binding *ns* doesn't affect read-string for auto-resolved keywords (F138)
 
 ## Resolved Issues (this session)

src/builtins/collections.zig

@@ -929,15 +929,45 @@ pub fn applyFn(allocator: Allocator, args: []const Value) anyerror!Value {
 
     const f = args[0];
     const last_arg = args[args.len - 1];
+    const middle_count = args.len - 2; // exclude f and last_arg
+
+    // For variadic fn_val, avoid realizing infinite seqs (F99).
+    // Build a lazy cons chain (like JVM's list*) and peel off only fixed params.
+    if (f.tag() == .fn_val) {
+        if (findVariadicFixedCount(f.asFn())) |fixed_count| {
+            // Build arg_seq = list*(middle_args, last_arg) via cons chain
+            var arg_seq = if (last_arg == Value.nil_val) Value.nil_val else last_arg;
+            var i = middle_count;
+            while (i > 0) {
+                i -= 1;
+                const cell = try allocator.create(value_mod.Cons);
+                cell.* = .{ .first = args[1 + i], .rest = arg_seq };
+                arg_seq = Value.initCons(cell);
+            }
+
+            // Take exactly fixed_count items from arg_seq
+            const call_args = try allocator.alloc(Value, fixed_count + 1);
+            for (0..fixed_count) |j| {
+                call_args[j] = try firstFn(allocator, &.{arg_seq});
+                arg_seq = try restFn(allocator, &.{arg_seq});
+            }
+
+            // Remaining seq is the rest param (lazy!) — convert to seq or nil
+            call_args[fixed_count] = try seqFn(allocator, &.{arg_seq});
+
+            // Signal VM/TreeWalk that the rest arg is already a seq (F99)
+            bootstrap.apply_rest_is_seq = true;
+            return bootstrap.callFnVal(allocator, f, call_args);
+        }
+    }
 
-    // Collect spread args from last collection
+    // Non-variadic or non-fn_val: collect all items eagerly (existing path)
     const spread_items: []const Value = if (last_arg == Value.nil_val)
         &.{}
     else
         try collectSeqItems(allocator, last_arg);
 
     // Build final args: middle args + spread items
-    const middle_count = args.len - 2; // exclude f and last_arg
     const total = middle_count + spread_items.len;
     const call_args = try allocator.alloc(Value, total);
     if (middle_count > 0) {
@@ -1008,6 +1038,32 @@ pub fn applyFn(allocator: Allocator, args: []const Value) anyerror!Value {
     };
 }
 
+/// Find the fixed param count of a variadic arity, if any.
+/// Returns null if the function has no variadic arity.
+fn findVariadicFixedCount(fn_obj: *const value_mod.Fn) ?usize {
+    const FnProto = @import("../compiler/chunk.zig").FnProto;
+    const FnNode = @import("../analyzer/node.zig").FnNode;
+
+    if (fn_obj.kind == .bytecode) {
+        const primary: *const FnProto = @ptrCast(@alignCast(fn_obj.proto));
+        if (primary.variadic) return primary.arity -| 1;
+        if (fn_obj.extra_arities) |extras| {
+            for (extras) |extra| {
+                const p: *const FnProto = @ptrCast(@alignCast(extra));
+                if (p.variadic) return p.arity -| 1;
+            }
+        }
+    } else {
+        // TreeWalk Closure: first field is *const FnNode (avoid importing tree_walk.zig
+        // to prevent circular dependency: bootstrap → collections → tree_walk → bootstrap)
+        const fn_node_ptr: *const *const FnNode = @ptrCast(@alignCast(fn_obj.proto));
+        for (fn_node_ptr.*.arities) |a| {
+            if (a.variadic) return a.params.len - 1;
+        }
+    }
+    return null;
+}
+
 /// (vector & items) — creates a vector from arguments.
 pub fn vectorFn(allocator: Allocator, args: []const Value) anyerror!Value {
     const items = try allocator.alloc(Value, args.len);

src/evaluator/tree_walk.zig

@@ -678,6 +678,10 @@ pub const TreeWalk = struct {
             const rest_args = args[fixed_count..];
             const rest_val: Value = if (rest_args.len == 0)
                 Value.nil_val
+            else if (rest_args.len == 1 and bootstrap.apply_rest_is_seq) blk2: {
+                bootstrap.apply_rest_is_seq = false;
+                break :blk2 rest_args[0]; // Already a seq from apply's lazy path (F99)
+            }
             else blk: {
                 const collections = @import("../runtime/collections.zig");
                 const items = self.allocator.alloc(Value, rest_args.len) catch return error.OutOfMemory;

src/runtime/bootstrap.zig

@@ -996,6 +996,11 @@ fn treewalkCallBridge(allocator: Allocator, fn_val: Value, args: []const Value)
 /// Per-thread for concurrency (Phase 48).
 pub threadlocal var last_thrown_exception: ?Value = null;
 
+/// Flag set by apply's lazy variadic path (F99). When true, the single rest arg
+/// in the next variadic call is already a seq and should not be re-wrapped in a list.
+/// Consumed (reset to false) by VM/TreeWalk rest packing code.
+pub threadlocal var apply_rest_is_seq: bool = false;
+
 /// Execute a bytecode fn_val via a new VM instance.
 /// Heap-allocates the VM to avoid C stack overflow from recursive
 /// VM → TreeWalk → VM calls (VM struct is ~500KB due to fixed-size stack).

src/vm/vm.zig

@@ -1481,6 +1481,9 @@ pub const VM = struct {
                 if (rest_count == 0) {
                     // No rest args: rest param is nil (matches Clojure/TreeWalk behavior)
                     self.stack[args_start + fixed] = Value.nil_val;
+                } else if (rest_count == 1 and bootstrap.apply_rest_is_seq) {
+                    // Already a seq from apply's lazy path (F99) — use directly
+                    bootstrap.apply_rest_is_seq = false;
                 } else {
                     const rest_items = self.allocator.alloc(Value, rest_count) catch return error.OutOfMemory;
                     for (0..rest_count) |i| {