fix(io): read-line reads process stdin — *in* root is now a stdin reader

Smell-audited: 1: the user-filed bug note suspected a TTY-only line-editor
path; the actual root cause was *in*'s nil root (D-414's known "no
process-stdin reader yet" hole) — read-line returned nil EVERYWHERE
including interactive terminals, not just pipes.

rt/__stdin-reader mints a text_io Reader in stdin mode: demand-filled via
blocking std.posix.read (clj System.in parity) — readLine buffers until a
full line or EOF, .read/.peek buffer one codepoint (chunk-boundary
multibyte-safe); a zero-byte read latches stdin_eof. core.clj's *in* root
is now (rt/__stdin-reader); with-in-str still shadows it with a string
reader via binding. Fixes `printf 'x\n' | cljw -e '(read-line)'` -> nil
(clj/bb read the line); unblocks cw-arcade rush-hour's piped playthrough.
e2e phase16_stdin_read_line (6 cases: pipe/redirect/EOF-line/CRLF/
with-in-str-shadow/.read codepoints) + registered in run_all.sh same
commit; line-seq over *in* verified.

Author: chaploud

src/lang/clj/clojure/core.clj

@@ -50,10 +50,11 @@
 ;; capture are plain `(binding [*out* (rt/__string-writer)] …)` rebinds.
 (def ^:dynamic *out* (rt/__stdout-writer))
 (def ^:dynamic *err* (rt/__stderr-writer))
-;; `*in*` — the bindable input reader var (D-414). ROOT is nil (no process-stdin
-;; reader yet); `with-in-str` / `(binding [*in* rdr] …)` set it to a host reader
-;; (e.g. `(rt/__string-reader s)`). `read-line` derefs it.
-(def ^:dynamic *in* nil)
+;; `*in*` — the bindable input reader var (D-414). ROOT is a process-stdin
+;; reader (demand-filled, blocking — clj `System.in` parity), so `(read-line)`
+;; works on piped/redirected/interactive stdin; `with-in-str` /
+;; `(binding [*in* rdr] …)` rebind it to a string reader.
+(def ^:dynamic *in* (rt/__stdin-reader))
 ;; `*print-length*` / `*print-level*` (ADR-0088) are interned in Zig
 ;; (`bootstrap.registerPrintLimitVars`) alongside the other cached-pointer
 ;; dynamic vars (*ns*, *data-readers*) so the renderer reads them via a cached
@@ -912,9 +913,9 @@
         nil
         (cons line (lazy-seq (line-seq rdr)))))))
 
-;; `(read-line)` — read the next line from `*in*` (a host reader), or nil at EOF
-;; / when `*in*` is unbound (D-414; cljw has no process-stdin reader yet, so the
-;; root nil yields nil rather than blocking). Bind `*in*` via `with-in-str`.
+;; `(read-line)` — read the next line from `*in*` (a host reader), or nil at
+;; EOF. The root is a process-stdin reader (blocking, clj parity); a nil-bound
+;; `*in*` still yields nil rather than raising.
 (def read-line
   (fn* [] (when (some? *in*) (.readLine *in*))))
 

src/runtime/io/text_io.zig

@@ -160,8 +160,53 @@ const ReaderState = struct {
     pos: usize,
     /// 1-slot codepoint pushback (`.unread`); consulted first by `.read`/`.peek`.
     pushback: ?u21,
+    /// stdin mode (the `*in*` root reader): `data` is a demand-filled buffer
+    /// pulled from process stdin (blocking, matching clj's `System.in`) rather
+    /// than a fixed string. False for `with-in-str` string readers.
+    stdin: bool = false,
+    /// stdin mode: a zero-byte read happened — no more fills.
+    stdin_eof: bool = false,
 };
 
+/// stdin mode: pull one chunk from process stdin into `data`. Returns false
+/// when EOF (or a read error, treated as EOF) ends the stream. Blocking on a
+/// TTY is the correct clj-parity behaviour (read-line waits for input).
+fn fillFromStdin(rt: *Runtime, st: *ReaderState) bool {
+    if (st.stdin_eof) return false;
+    var chunk: [4096]u8 = undefined;
+    const n = std.posix.read(std.Io.File.stdin().handle, &chunk) catch {
+        st.stdin_eof = true;
+        return false;
+    };
+    if (n == 0) {
+        st.stdin_eof = true;
+        return false;
+    }
+    st.data.appendSlice(rt.gc.infra, chunk[0..n]) catch {
+        st.stdin_eof = true;
+        return false;
+    };
+    return true;
+}
+
+/// stdin mode: buffer until a full line (`\n` past `pos`) or EOF is present,
+/// so the readLine slice logic sees the same world a string reader does.
+fn ensureLineBuffered(rt: *Runtime, st: *ReaderState) void {
+    if (!st.stdin) return;
+    while (std.mem.findScalarPos(u8, st.data.items, st.pos, '\n') == null and !st.stdin_eof) {
+        if (!fillFromStdin(rt, st)) break;
+    }
+}
+
+/// stdin mode: buffer at least one full codepoint (≤ 4 bytes) past `pos` or
+/// EOF, so `decodeAt` never mistakes a chunk-boundary split for invalid UTF-8.
+fn ensureCodepointBuffered(rt: *Runtime, st: *ReaderState) void {
+    if (!st.stdin) return;
+    while (st.data.items.len < st.pos + 4 and !st.stdin_eof) {
+        if (!fillFromStdin(rt, st)) break;
+    }
+}
+
 fn readerStateOf(recv: Value) *ReaderState {
     return @ptrFromInt(host_instance.asHostInstance(recv).state[0]);
 }
@@ -196,26 +241,26 @@ fn decodeAt(st: *ReaderState) ?Decoded {
 /// `(.read r)` — next codepoint as an int (JVM Reader.read), -1 at EOF. Honors a
 /// pending `.unread` first.
 fn readCharMethod(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
-    _ = rt;
     _ = env;
     try error_catalog.checkArity("read", args, 1, loc);
     const st = readerStateOf(args[0]);
     if (st.pushback) |cp| {
         st.pushback = null;
         return Value.initInteger(@intCast(cp));
     }
+    ensureCodepointBuffered(rt, st);
     const d = decodeAt(st) orelse return Value.initInteger(-1);
     st.pos += d.len;
     return Value.initInteger(@intCast(d.cp));
 }
 
 /// `(.peek r)` — next codepoint as an int WITHOUT advancing; -1 at EOF.
 fn peekCharMethod(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
-    _ = rt;
     _ = env;
     try error_catalog.checkArity("peek", args, 1, loc);
     const st = readerStateOf(args[0]);
     if (st.pushback) |cp| return Value.initInteger(@intCast(cp));
+    ensureCodepointBuffered(rt, st);
     const d = decodeAt(st) orelse return Value.initInteger(-1);
     return Value.initInteger(@intCast(d.cp));
 }
@@ -241,6 +286,9 @@ fn readLineMethod(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocat
     _ = env;
     try error_catalog.checkArity("readLine", args, 1, loc);
     const st = readerStateOf(args[0]);
+    // stdin mode: buffer the full line first so both branches below see the
+    // same world a string reader does (D-414 stdin root).
+    ensureLineBuffered(rt, st);
     // Fast path: no pushback → return a slice of the source (cf. host_stream).
     if (st.pushback == null) {
         const items = st.data.items;
@@ -434,6 +482,18 @@ fn inReaderFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation)
     return mintReader(rt, string_mod.asString(args[0]));
 }
 
+/// `(rt/__stdin-reader)` — a text_io Reader over PROCESS stdin (demand-filled,
+/// blocking; clj `System.in` parity). The `*in*` ROOT (core.clj) — so
+/// `(read-line)` works on piped/redirected/interactive stdin, not just under
+/// `with-in-str` (the 2026-07-06 non-TTY read-line-nil bug).
+fn stdinReaderFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
+    _ = env;
+    try error_catalog.checkArity("__stdin-reader", args, 0, loc);
+    const st = try rt.gc.infra.create(ReaderState);
+    st.* = .{ .data = .empty, .pos = 0, .pushback = null, .stdin = true };
+    return host_instance.alloc(rt, &reader_descriptor, .{ @intFromPtr(st), 0, 0, 0 });
+}
+
 /// `(rt/__writer->str w)` — the accumulated string of a writer (`.string`
 /// mode; process modes own no buffer so return ""). Backs `with-out-str`.
 fn writerToStrFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
@@ -451,6 +511,7 @@ const PRIMS = [_]Prim{
     .{ .name = "__string-writer", .f = &stringWriterFn },
     .{ .name = "__writer->str", .f = &writerToStrFn },
     .{ .name = "__in-reader", .f = &inReaderFn },
+    .{ .name = "__stdin-reader", .f = &stdinReaderFn },
 };
 
 /// Register the text_io `rt/__*` writer primitives. Called from

test/e2e/phase16_stdin_read_line.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# test/e2e/phase16_stdin_read_line.sh — `(read-line)` on process stdin.
+#
+# The 2026-07-06 user-filed bug: `*in*`'s root was nil (no process-stdin
+# reader), so `(read-line)` returned nil on piped/redirected/interactive
+# stdin while clj/bb read the lines. The root is now `(rt/__stdin-reader)`
+# — a demand-filled blocking reader over process stdin (clj System.in
+# parity). Layer 2 (e2e CLI) per ADR-0021; non-TTY stdin is exactly what
+# this harness provides, so the regression is CI-visible.
+
+set -euo pipefail
+cd "$(dirname "$0")/../.."
+
+BIN="zig-out/bin/cljw"
+[ -n "${CLJW_SKIP_BUILD:-}" ] || zig build -Dwasm -Doptimize="${CLJW_OPT:-ReleaseSafe}" >/dev/null
+
+fail() { echo "FAIL $1" >&2; exit 1; }
+assert_eq() { local n="$1" g="$2" w="$3"; [[ "$g" == "$w" ]] || fail "$n: got '$g' want '$w'"; echo "PASS $n -> $w"; }
+
+# Piped stdin: two lines then EOF (clj: ["hello" "world" nil]).
+assert_eq 'pipe_lines' \
+  "$(printf 'hello\nworld\n' | "$BIN" -e '(pr-str [(read-line) (read-line) (read-line)])' | tail -1)" \
+  '"[\"hello\" \"world\" nil]"'
+
+# File redirect behaves the same (not pipe-specific).
+tmp_in="$(mktemp)"; printf 'redirected\n' > "$tmp_in"
+assert_eq 'redirect_line' \
+  "$("$BIN" -e '(read-line)' < "$tmp_in" | tail -1)" \
+  '"redirected"'
+rm -f "$tmp_in"
+
+# A final line WITHOUT a trailing newline still reads (EOF-terminated line).
+assert_eq 'no_trailing_newline' \
+  "$(printf 'lastline' | "$BIN" -e '(pr-str [(read-line) (read-line)])' | tail -1)" \
+  '"[\"lastline\" nil]"'
+
+# CRLF terminators are stripped (the reader's \r\n handling on stdin).
+assert_eq 'crlf' \
+  "$(printf 'crlf\r\n' | "$BIN" -e '(read-line)' | tail -1)" \
+  '"crlf"'
+
+# with-in-str still shadows the stdin root (string reader wins inside).
+assert_eq 'with_in_str_shadows' \
+  "$(printf 'outer\n' | "$BIN" -e '(pr-str [(with-in-str "inner\n" (read-line)) (read-line)])' | tail -1)" \
+  '"[\"inner\" \"outer\"]"'
+
+# .read on stdin: codepoints stream through (multibyte-safe demand fill).
+assert_eq 'read_codepoint' \
+  "$(printf 'あZ' | "$BIN" -e '(pr-str [(.read *in*) (.read *in*) (.read *in*)])' | tail -1)" \
+  '"[12354 90 -1]"'
+
+echo "ALL phase16_stdin_read_line PASS"

test/run_all.sh

@@ -618,6 +618,7 @@ run_step "e2e_phase16_fs_jail"              "bash test/e2e/phase16_fs_jail.sh"
 run_step "e2e_phase16_java_io_file"         "bash test/e2e/phase16_java_io_file.sh"
 run_step "e2e_phase16_clojure_java_io"      "bash test/e2e/phase16_clojure_java_io.sh"
 run_step "e2e_phase16_host_stream"          "bash test/e2e/phase16_host_stream.sh"
+run_step "e2e_phase16_stdin_read_line"      "bash test/e2e/phase16_stdin_read_line.sh"
 run_step "e2e_phase16_clojure_java_io_streams" "bash test/e2e/phase16_clojure_java_io_streams.sh"
 run_step "e2e_phase16_clojure_java_io_copy" "bash test/e2e/phase16_clojure_java_io_copy.sh"
 run_step "e2e_phase16_cljw_json_fs"         "bash test/e2e/phase16_cljw_json_fs.sh"