@scriptc/compiler 0.0.22 → 0.0.24

package/dist/backend/llvm/emitter.js

@@ -1,4 +1,5 @@
 import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, islandCallbackRet, islandPromisePayloadTag, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
+import { matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
 import { computeMayThrow } from "../emission/may-throw.js";
 import { mangleArgPack, mangleAsyncSpawn, mangleClassNew, mangleClassObj, mangleClassRetain, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenResThunk, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordNew, mangleRecordStruct, mangleResolveThunk, mangleTrampoline, mangleVtStruct, mangleWrapper } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
@@ -38,6 +39,7 @@ function llStrBytes(text) {
  * Throwing members (MAY_THROW_LIB_FNS) and everything unlisted refuse by
  * name. */
 const LIB_FN_SYMS = {
+    "util.parseArgs": "scr_util_parse_args",
     "math.maxArr": "scr_math_max_arr",
     "math.minArr": "scr_math_min_arr",
     "math.min": "scr_math_min",
@@ -129,13 +131,36 @@ const LIB_FN_SYMS = {
     "process.stderrWrite": "scr_process_stderr_write",
     "process.isTTY": "scr_process_is_tty",
     "date.now": "scr_date_now",
+    "date.newNow": "scr_date_now",
+    "date.newMs": "scr_date_new_ms",
+    "date.newString": "scr_date_parse_get_time",
+    "date.getTime": "scr_date_get_time",
+    "date.valueOf": "scr_date_get_time",
     "date.parseGetTime": "scr_date_parse_get_time",
     "date.utc": "scr_date_utc",
+    "date.getFullYear": "scr_date_get_full_year_local",
+    "date.getUTCFullYear": "scr_date_get_full_year_utc",
+    "date.getMonth": "scr_date_get_month_local",
+    "date.getUTCMonth": "scr_date_get_month_utc",
+    "date.getDate": "scr_date_get_date_local",
+    "date.getUTCDate": "scr_date_get_date_utc",
+    "date.getDay": "scr_date_get_day_local",
+    "date.getUTCDay": "scr_date_get_day_utc",
+    "date.getHours": "scr_date_get_hours_local",
+    "date.getUTCHours": "scr_date_get_hours_utc",
+    "date.getMinutes": "scr_date_get_minutes_local",
+    "date.getUTCMinutes": "scr_date_get_minutes_utc",
+    "date.getSeconds": "scr_date_get_seconds_local",
+    "date.getUTCSeconds": "scr_date_get_seconds_utc",
+    "date.getMilliseconds": "scr_date_get_milliseconds",
+    "date.getUTCMilliseconds": "scr_date_get_milliseconds",
+    "date.getTimezoneOffset": "scr_date_get_timezone_offset",
     "fs.existsSync": "scr_fs_exists",
     // ── the throwing slice (MAY_THROW_LIB_FNS members): the generic path
     // emits the standard pending check after each — emit-exprs.ts's finish.
     "process.cpuPrevValidate": "scr_cpu_prev_validate",
     "date.toISOString": "scr_date_to_iso",
+    "date.toISOStringValue": "scr_date_to_iso",
     "process.chdir": "scr_process_chdir",
     "fs.writeFileSync": "scr_fs_write_file",
     "fs.appendFileSync": "scr_fs_append_file",
@@ -151,6 +176,7 @@ const LIB_FN_SYMS = {
     "fs.unlinkSync": "scr_fs_unlink",
     "fs.chmodSync": "scr_fs_chmod",
     "fs.copyFileSync": "scr_fs_copyfile",
+    "fs.renameSync": "scr_fs_rename",
     "fs.accessSync": "scr_fs_access",
     // node:assert (scr_assert.c): all args borrowed; failures throw the
     // catchable AssertionError. The never-throwing members ride along.
@@ -213,6 +239,8 @@ const LIB_FN_SYMS = {
     "fs.lstatSync": "scr_fs_lstat",
     "fs.openSync": "scr_fs_open",
     "fs.readSync": "scr_fs_read_sync",
+    "fs.writeSync": "scr_fs_write_sync",
+    "fs.writeStrSync": "scr_fs_write_str_sync",
     "fs.closeSync": "scr_fs_close",
     // string_decoder (scr_bytes.c): stateless helpers over (enc, pending,
     // chunk) — never throw.
@@ -223,8 +251,12 @@ const LIB_FN_SYMS = {
     "stats.isDirectory": "scr_stats_is_dir",
     "stats.isSymbolicLink": "scr_stats_is_symlink",
     "stats.size": "scr_stats_size",
+    "stats.blocks": "scr_stats_blocks",
+    "stats.nlink": "scr_stats_nlink",
+    "stats.atimeMs": "scr_stats_atime_ms",
     "stats.mtimeMs": "scr_stats_mtime_ms",
     "text.decode": "scr_text_decode",
+    "text.decodeLegacy": "scr_text_decode_legacy",
     "zlib.deflateSync": "scr_zlib_deflate",
     "zlib.inflateSync": "scr_zlib_inflate",
     // The CA-store unit. get/set throw (an unknown type name, a
@@ -332,15 +364,25 @@ const LIB_FN_SYMS = {
     // so it is special-cased in emitLibCall (the fs.readFileSync pattern).
     "fsp.readFileBytes": "scr_fsp_read_file_bytes",
     "fsp.writeFile": "scr_fsp_write_file",
+    "fsp.writeFileMode": "scr_fsp_write_file_mode",
     "fsp.mkdir": "scr_fsp_mkdir",
     "fsp.mkdirMode": "scr_fsp_mkdir_mode",
     "fsp.mkdirRecursive": "scr_fsp_mkdir_recursive",
     "fsp.mkdirRecursiveMode": "scr_fsp_mkdir_recursive_mode",
     "fsp.unlink": "scr_fsp_unlink",
     "fsp.chmod": "scr_fsp_chmod",
+    "fsp.rename": "scr_fsp_rename",
     "fsp.readdir": "scr_fsp_readdir",
     "fsp.rm": "scr_fsp_rm",
     "fsp.stat": "scr_fsp_stat",
+    "fsp.open": "scr_fsp_open",
+    "fileHandle.fd": "scr_file_handle_fd",
+    "fileHandle.close": "scr_file_handle_close_promise",
+    "fileHandle.readFile": "scr_file_handle_read_file_promise",
+    "fileHandle.readFileBytes": "scr_file_handle_read_file_bytes_promise",
+    "fileHandle.writeFile": "scr_file_handle_write_file_promise",
+    "fileHandle.writeFileBytes": "scr_file_handle_write_file_bytes_promise",
+    "fileHandle.stat": "scr_file_handle_stat_promise",
     "sym.new": "scr_sym_new",
     "sym.for": "scr_sym_for",
     "sym.toString": "scr_sym_to_string",
@@ -352,9 +394,11 @@ const LIB_FN_SYMS = {
     // the generic path emits the standard pending check). typeof and the
     // ambient-this read never throw. The fs dyn read is the sync-fs story.
     "fetch.start": "scr_fetch_static",
+    "fetch.responseNew": "scr_fetch_response_new",
     "fetch.responseJson": "scr_fetch_response_json",
     "fetch.responseText": "scr_fetch_response_text",
     "fetch.responseBytes": "scr_fetch_response_bytes",
+    "fetch.abortControllerNew": "scr_fetch_abort_controller_new",
     "fetch.abortTimeout": "scr_fetch_abort_timeout",
     "fetch.abortNow": "scr_fetch_abort_now",
     "fetch.abortAny": "scr_fetch_abort_any",
@@ -829,6 +873,8 @@ class LlEmitter {
     jumpTargets = [];
     currentLocals = new Map();
     captureIds = new Set();
+    /** Active canonical byte-loop induction bindings: local id → i64 slot. */
+    integerLoopBindings = new Map();
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
      * inside one runs every crossed finally (innermost first) before the
      * actual ret — the C emitter's pending-return path, with the finally
@@ -940,6 +986,7 @@ class LlEmitter {
     llType(t) {
         switch (t.kind) {
             case "f64":
+            case "date":
                 return "double";
             case "bool":
                 return "i1";
@@ -957,6 +1004,7 @@ class LlEmitter {
             case "url":
             case "searchParams":
             case "stats":
+            case "fileHandle":
             case "spawnRes":
             case "child":
             case "childStream":
@@ -1192,6 +1240,11 @@ class LlEmitter {
             // scr_runtime.h's natural alignment: kind at 8, f64 at 16, b at 24,
             // payload at 32).
             `%ScrCaught = type { i64, i32, double, i8, ptr, ptr, ptr, ptr }`,
+            // ScrBytes { rc, len, elem(i32+pad), data, backing }. Indexed
+            // typed-array access GEPs through this directly: the IR type already
+            // fixes elem, so the hot path needs neither a runtime kind load nor
+            // the generic scr_bytes_get/set call.
+            `%ScrBytes = type { i64, i64, i32, ptr, ptr }`,
             // The capture box { rc, kind, obj_retain, obj_release, obj_trace,
             // slot } — TDZ reads peek the payload slot (offset 40) directly.
             `%ScrBox = type { i64, i32, ptr, ptr, ptr, i64 }`,
@@ -1696,6 +1749,7 @@ class LlEmitter {
                     tr.push(`  call void @scr_promise_fulfill_void(ptr %pr)`);
                     break;
                 case "f64":
+                case "date":
                     this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
                     tr.push(`  call void @scr_promise_fulfill_f64(ptr %pr, double %r)`);
                     break;
@@ -1851,6 +1905,7 @@ class LlEmitter {
                     tr.push(`  br label %done ; void body: the done value is undefined (NONE)`);
                     break;
                 case "f64":
+                case "date":
                     this.declare(`declare void @scr_gen_out_f64(ptr, double)`);
                     tr.push(`  call void @scr_gen_out_f64(ptr %g, double %r)`, `  br label %done`);
                     break;
@@ -2072,7 +2127,7 @@ class LlEmitter {
         const t = this.currentReturnType;
         if (t.kind === "void")
             this.B.terminate("ret void");
-        else if (t.kind === "f64")
+        else if (t.kind === "f64" || t.kind === "date")
             this.B.terminate(`ret double ${f64Lit(0)}`);
         else if (t.kind === "bool")
             this.B.terminate("ret i1 false");
@@ -2104,7 +2159,10 @@ class LlEmitter {
     emitThrowValue(v) {
         const B = this.B;
         const t = v.type;
-        if (t.kind === "f64") {
+        if (t.kind === "date") {
+            throw new Error("LLVM emitter bug: Date throw reached backend");
+        }
+        else if (t.kind === "f64") {
             this.declare(`declare void @scr_throw_f64(double)`);
             B.line(`call void @scr_throw_f64(double ${v.name})`);
         }
@@ -2153,6 +2211,8 @@ class LlEmitter {
                 B.line(`${t} = icmp ne i64 ${len}, 0`);
                 return t;
             }
+            case "date":
+                return "true";
             case "array":
             case "record":
             case "object":
@@ -2167,6 +2227,7 @@ class LlEmitter {
             case "url":
             case "searchParams":
             case "stats":
+            case "fileHandle":
             case "spawnRes":
             case "child":
             case "childStream":
@@ -2247,6 +2308,9 @@ class LlEmitter {
                             B.line(`store i1 ${t}, ptr ${slot}`);
                             break;
                         }
+                        case "date":
+                            B.line(`store i1 true, ptr ${slot} ; Date objects are truthy`);
+                            break;
                         case "array":
                         case "record":
                         case "object":
@@ -2261,6 +2325,7 @@ class LlEmitter {
                         case "url":
                         case "searchParams":
                         case "stats":
+                        case "fileHandle":
                         case "spawnRes":
                         case "child":
                         case "childStream":
@@ -2595,6 +2660,7 @@ class LlEmitter {
         this.jumpTargets = [];
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
         this.captureIds = new Set((fn.captures ?? []).map((c) => c.localId));
+        this.integerLoopBindings.clear();
         this.chainSlots.clear();
         this.finallyStack = [];
         this.tryStack = [];
@@ -2791,13 +2857,17 @@ class LlEmitter {
             }
             case "bytesSet": {
                 // Typed-array element write: same evaluation order as arraySet;
-                // the value is a scalar (the runtime coerces JS-exactly), so no
-                // ownership moves. Any invalid index traps — no append.
-                const arr = this.emitExpr(s.arr);
-                const idx = this.emitExpr(s.index);
+                // the value is a scalar (the kind-specific inline path coerces
+                // JS-exactly), so no ownership moves. Any invalid index traps — no
+                // append. IrBytesElem is static, so never rediscover it through the
+                // generic runtime switch in a hot loop.
+                const arr = this.emitBytesReceiver(s.arr, [s.index, s.value]);
+                const integerIndex = this.emitIntegerLoopIndex(s.index);
+                const idx = integerIndex ?? this.emitExpr(s.index).name;
                 const v = this.emitExpr(s.value);
-                this.declare(`declare void @scr_bytes_set(ptr, double, double)`);
-                B.line(`call void @scr_bytes_set(ptr ${arr.name}, double ${idx.name}, double ${v.name})`);
+                if (s.arr.type.kind !== "bytes")
+                    throw new Error("llvm emitter bug: bytesSet on non-bytes");
+                this.emitBytesSet(s.arr.type.elem, arr.name, idx, v.name, integerIndex !== null);
                 break;
             }
             case "fieldSet":
@@ -3054,9 +3124,18 @@ class LlEmitter {
             case "for": {
                 // The init's scope wraps the whole loop (break/continue must NOT
                 // release it — scopeDepth captured after the push, C parity).
+                const integerLoop = matchIntegerBytesForLoop(s, this.currentLocals);
                 this.scopes.push([]);
-                if (s.init)
+                let integerSlot = null;
+                if (integerLoop) {
+                    integerSlot = B.slot();
+                    B.entryAllocas.push(`${integerSlot} = alloca i64 ; integer induction ${this.currentLocals.get(integerLoop.localId).name}`);
+                    B.line(`store i64 0, ptr ${integerSlot}`);
+                    this.integerLoopBindings.set(integerLoop.localId, integerSlot);
+                }
+                else if (s.init) {
                     this.emitStmt(s.init);
+                }
                 const lc = B.newLabel("loop.c");
                 const lb = B.newLabel("loop.b");
                 const le = B.newLabel("loop.e");
@@ -3070,7 +3149,19 @@ class LlEmitter {
                 const lu = s.update || freshens ? B.newLabel("loop.u") : lc;
                 B.br(lc);
                 B.startBlock(lc);
-                if (s.cond)
+                if (integerLoop && integerSlot) {
+                    const receiver = this.emitBytesReceiver(integerLoop.limitReceiver, []);
+                    const lenPtr = B.tmp();
+                    const len = B.tmp();
+                    const index = B.tmp();
+                    const inBounds = B.tmp();
+                    B.line(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver.name}, i64 0, i32 1`);
+                    B.line(`${len} = load i64, ptr ${lenPtr}`);
+                    B.line(`${index} = load i64, ptr ${integerSlot}`);
+                    B.line(`${inBounds} = icmp ult i64 ${index}, ${len}`);
+                    B.condBr(inBounds, lb, le);
+                }
+                else if (s.cond)
                     B.condBr(this.emitCondition(s.cond), lb, le);
                 else
                     B.br(lb);
@@ -3102,12 +3193,21 @@ class LlEmitter {
                         // The wrapper scope's entry releases whatever the slot points
                         // to at loop exit — now the freshest binding. Nothing to fix.
                     }
-                    if (s.update)
+                    if (integerLoop && integerSlot) {
+                        const old = B.tmp();
+                        const next = B.tmp();
+                        B.line(`${old} = load i64, ptr ${integerSlot}`);
+                        B.line(`${next} = add nuw i64 ${old}, 1`);
+                        B.line(`store i64 ${next}, ptr ${integerSlot}`);
+                    }
+                    else if (s.update)
                         this.emitStmt(s.update);
                     B.br(lc);
                 }
                 B.startBlock(le);
                 this.releaseScope(this.scopes.pop());
+                if (integerLoop)
+                    this.integerLoopBindings.delete(integerLoop.localId);
                 break;
             }
             case "forOf": {
@@ -3585,6 +3685,14 @@ class LlEmitter {
                 // tag-only); one reaching the generic dispatch escaped its wrap.
                 throw new Error(`llvm emitter bug: bare unitLit '${e.unit}'`);
             case "varRef": {
+                const integerSlot = this.integerLoopBindings.get(e.localId);
+                if (integerSlot !== undefined) {
+                    const integer = B.tmp();
+                    const number = B.tmp();
+                    B.line(`${integer} = load i64, ptr ${integerSlot}`);
+                    B.line(`${number} = uitofp i64 ${integer} to double`);
+                    return { name: number, type: e.type };
+                }
                 const b = this.binding(e.localId);
                 if (b.kind === "boxed") {
                     // Reads go through the shared binding; ref kinds come out +1.
@@ -5280,7 +5388,7 @@ class LlEmitter {
                     throw new Error("llvm emitter bug: yieldExpr with no operand (frontend fills undefined)");
                 const v = this.emitExpr(e.value);
                 const yt = e.value.type;
-                if (yt.kind === "f64") {
+                if (yt.kind === "f64" || yt.kind === "date") {
                     this.declare(`declare void @scr_gen_yield_f64(double)`);
                     B.line(`call void @scr_gen_yield_f64(double ${v.name})`);
                 }
@@ -5300,7 +5408,7 @@ class LlEmitter {
                     return { name: "", type: e.type };
                 }
                 const t = B.tmp();
-                if (e.type.kind === "f64") {
+                if (e.type.kind === "f64" || e.type.kind === "date") {
                     this.declare(`declare double @scr_gen_take_in_f64()`);
                     B.line(`${t} = call double @scr_gen_take_in_f64()`);
                     return { name: t, type: e.type };
@@ -5332,7 +5440,7 @@ class LlEmitter {
                     store(a.name, e.arg.type);
                 };
                 const parkIn = (name, t) => {
-                    if (t.kind === "f64") {
+                    if (t.kind === "f64" || t.kind === "date") {
                         this.declare(`declare void @scr_gen_in_f64(ptr, double)`);
                         B.line(`call void @scr_gen_in_f64(ptr ${g.name}, double ${name})`);
                     }
@@ -5378,7 +5486,7 @@ class LlEmitter {
                     }
                     else {
                         sendArg((name, t) => {
-                            if (t.kind === "f64") {
+                            if (t.kind === "f64" || t.kind === "date") {
                                 this.declare(`declare void @scr_gen_ret_f64(ptr, double)`);
                                 B.line(`call void @scr_gen_ret_f64(ptr ${g.name}, double ${name})`);
                             }
@@ -5431,7 +5539,7 @@ class LlEmitter {
                     return { name: "", type: e.type };
                 }
                 const t = B.tmp();
-                if (e.type.kind === "f64") {
+                if (e.type.kind === "f64" || e.type.kind === "date") {
                     this.declare(`declare double @scr_await_f64(ptr)`);
                     B.line(`${t} = call double @scr_await_f64(ptr ${pr.name})`);
                 }
@@ -5511,7 +5619,7 @@ class LlEmitter {
                 B.startBlock(lp);
                 const peek = this.unionPeek(u.name);
                 let awaited;
-                if (inner.kind === "f64") {
+                if (inner.kind === "f64" || inner.kind === "date") {
                     this.declare(`declare double @scr_await_f64(ptr)`);
                     const x = B.tmp();
                     B.line(`${x} = call double @scr_await_f64(ptr ${peek})`);
@@ -5588,7 +5696,7 @@ class LlEmitter {
                     return out;
                 }
                 let resolve;
-                const kindNums = { f64: 0, bool: 1, string: 2, void: 3 };
+                const kindNums = { f64: 0, date: 0, bool: 1, string: 2, void: 3 };
                 const kindNum = kindNums[inner.kind];
                 if (kindNum !== undefined) {
                     this.declare(`declare ptr @scr_make_resolve(ptr, i32)`);
@@ -5634,7 +5742,7 @@ class LlEmitter {
                 this.declare(`declare ptr @scr_make_reject(ptr)`);
                 const p = B.tmp();
                 B.line(`${p} = call ptr @scr_promise_new()`);
-                const kindNums = { f64: 0, bool: 1, string: 2, void: 3 };
+                const kindNums = { f64: 0, date: 0, bool: 1, string: 2, void: 3 };
                 const kindNum = kindNums[inner.kind];
                 const resolve = B.tmp();
                 if (kindNum !== undefined) {
@@ -5749,7 +5857,7 @@ class LlEmitter {
                     }
                     const v = this.emitExpr(e.args[0]);
                     const t = e.args[0].type;
-                    if (t.kind === "f64") {
+                    if (t.kind === "f64" || t.kind === "date") {
                         this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
                         B.line(`call void @scr_promise_fulfill_f64(ptr ${p}, double ${v.name})`);
                     }
@@ -7790,6 +7898,52 @@ class LlEmitter {
         this.resolveThunkDefs.push(...d);
         return sym;
     }
+    /** The fs.rename callback adapter: the runtime passes a borrowed Error
+     * or NULL and the thunk constructs the callback's owned, program-shaped
+     * Error | null union (or a dyn error/null in checkJs programs). */
+    fsRenameThunkFor(cbT) {
+        if (cbT.params.length === 0) {
+            this.declare(`declare void @scr_fs_rename_thunk0(ptr, ptr)`);
+            return "scr_fs_rename_thunk0";
+        }
+        const key = `fsren:${typeKey(cbT)}`;
+        let sym = this.resolveThunks.get(key);
+        if (sym)
+            return sym;
+        sym = `sc_fsren_${this.resolveThunks.size}`;
+        this.resolveThunks.set(key, sym);
+        const param = cbT.params[0];
+        const d = [
+            `define internal void @${sym}(ptr %cb, ptr %err) ${FN_ATTRS} { ; fs.rename callback ${typeKey(cbT)}`,
+            `entry:`,
+            `  %slot = alloca ptr`,
+            `  %has = icmp ne ptr %err, null`,
+            `  br i1 %has, label %yes, label %no`,
+            `yes:`,
+        ];
+        if (param.kind === "dyn") {
+            this.declare(`declare ptr @scr_dyn_from_error(ptr)`);
+            this.declare(`declare ptr @scr_dyn_new_null()`);
+            d.push(`  %de = call ptr @scr_dyn_from_error(ptr %err)`, `  store ptr %de, ptr %slot`, `  br label %go`, `no:`, `  %dn = call ptr @scr_dyn_new_null()`, `  store ptr %dn, ptr %slot`);
+        }
+        else {
+            if (param.kind !== "union")
+                throw new Error("llvm emitter bug: fs.rename error param not a union");
+            const def = this.unionsById.get(param.unionId);
+            const errTag = def ? def.arms.findIndex((a) => a.kind === "object" && a.className === "%Error") : -1;
+            const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
+            if (errTag < 0 || nullTag < 0)
+                throw new Error("llvm emitter bug: fs.rename error union lacks its arms");
+            this.declare(`declare ptr @scr_error_retain(ptr)`);
+            this.declare(`declare ptr @scr_error_retain_v(ptr)`);
+            this.declare(`declare void @scr_error_release_v(ptr)`);
+            this.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
+            d.push(`  %er = call ptr @scr_error_retain(ptr %err)`, `  %eu = call ptr @scr_union_new_ref(i32 ${errTag}, ptr %er, ptr @scr_error_retain_v, ptr @scr_error_release_v, ptr null)`, `  store ptr %eu, ptr %slot`, `  br label %go`, `no:`, `  store ptr ${this.unitInstanceRef(param.unionId, nullTag)}, ptr %slot`);
+        }
+        d.push(`  br label %go`, `go:`, `  %arg = load ptr, ptr %slot`, `  %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`, `  call void %fn(ptr %cb, ptr %arg)`, `  ret void`, `}`, ``);
+        this.resolveThunkDefs.push(...d);
+        return sym;
+    }
     /** The stream option-callback invoke adapter for one (kind, callback
      * type) — emit-async.ts's streamCbThunkFor: the runtime calls the
      * user's read/write/final/destroy/transform/flush (or the finished/
@@ -8095,7 +8249,7 @@ class LlEmitter {
             case "trimEnd":
                 return call("scr_str_trim_end", "ptr (ptr)", `ptr ${r.name}`, "ptr", true);
             case "split":
-                return call("scr_str_split", "ptr (ptr, ptr)", `ptr ${r.name}, ptr ${args[0].name}`, "ptr", true);
+                return call("scr_str_split_limit", "ptr (ptr, ptr, double)", `ptr ${r.name}, ptr ${args[0].name}, double ${args[1].name}`, "ptr", true);
             case "padStart":
                 return call("scr_str_pad_start", "ptr (ptr, double, ptr)", `ptr ${r.name}, double ${args[0].name}, ptr ${args[1].name}`, "ptr", true);
             case "padEnd":
@@ -8167,6 +8321,33 @@ class LlEmitter {
                 B.line(`${t} = call double @scr_arr_len(ptr ${r.name})`);
                 return { name: t, type: e.type };
             }
+            case "unshift": {
+                // Evaluate every argument before the first mutation, then insert
+                // from right to left so the final front order is source order.
+                const vs = e.args.map((a) => this.emitExpr(a));
+                if (acc === "ref")
+                    vs.forEach((v) => this.moveTemp(v));
+                this.declare(`declare double @scr_arr_unshift_${acc}(ptr, ${accArg})`);
+                let last = "";
+                for (let i = vs.length - 1; i >= 0; i--) {
+                    last = B.tmp();
+                    B.line(`${last} = call double @scr_arr_unshift_${acc}(ptr ${r.name}, ${accTy} ${vs[i].name})`);
+                }
+                if (last !== "")
+                    return { name: last, type: e.type };
+                this.declare(`declare double @scr_arr_len(ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call double @scr_arr_len(ptr ${r.name})`);
+                return { name: t, type: e.type };
+            }
+            case "unshiftSpread": {
+                // The runtime snapshots the borrowed source and handles self-spread.
+                const src = this.emitExpr(e.args[0]);
+                this.declare(`declare double @scr_arr_unshift_spread(ptr, ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call double @scr_arr_unshift_spread(ptr ${r.name}, ptr ${src.name})`);
+                return { name: t, type: e.type };
+            }
             case "pop": {
                 // Ownership of a refcounted element moves OUT of the array to
                 // this temp (+1 to us, the runtime does not release it).
@@ -8226,6 +8407,13 @@ class LlEmitter {
                 B.line(`${t} = call ptr @scr_arr_to_reversed(ptr ${r.name})`);
                 return this.own({ name: t, type: e.type });
             }
+            case "reverse": {
+                // Mutates in place and returns the same receiver as a fresh +1.
+                this.declare(`declare ptr @scr_arr_reverse(ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_arr_reverse(ptr ${r.name})`);
+                return this.own({ name: t, type: e.type });
+            }
             case "toSpliced": {
                 const start = this.emitExpr(e.args[0]);
                 const count = this.emitExpr(e.args[1]);
@@ -8625,6 +8813,260 @@ class LlEmitter {
             }
         }
     }
+    /** Whether an index/value expression can overwrite the bytes receiver
+     * binding. Kept deliberately conservative; uncertain or calling shapes
+     * retain the ordinary owned-receiver snapshot. */
+    isStableBytesOperand(e, receiverLocalId) {
+        switch (e.kind) {
+            case "numLit":
+            case "boolLit":
+            case "varRef":
+            case "incDec":
+                return true;
+            case "assignExpr":
+                // A bytes assignment nested under truthiness/ternary can still
+                // produce the numeric index/value expected by the outer access.
+                return (e.localId !== receiverLocalId &&
+                    this.isStableBytesOperand(e.value, receiverLocalId));
+            case "bin":
+                return (this.isStableBytesOperand(e.left, receiverLocalId) &&
+                    this.isStableBytesOperand(e.right, receiverLocalId));
+            case "unary":
+            case "toBool":
+                return this.isStableBytesOperand(e.operand, receiverLocalId);
+            case "logical":
+                return (this.isStableBytesOperand(e.left, receiverLocalId) &&
+                    this.isStableBytesOperand(e.right, receiverLocalId));
+            case "ternary":
+                return (this.isStableBytesOperand(e.cond, receiverLocalId) &&
+                    this.isStableBytesOperand(e.then, receiverLocalId) &&
+                    this.isStableBytesOperand(e.else_, receiverLocalId));
+            case "bytesIntrinsic":
+                return ((e.method === "get" || e.method === "length" || e.method === "byteLength") &&
+                    e.receiver.kind === "varRef" &&
+                    e.args.every((arg) => this.isStableBytesOperand(arg, receiverLocalId)));
+            default:
+                return false;
+        }
+    }
+    /** Borrow a direct, unboxed bytes binding when later operands are stable.
+     * Its scope/global owner keeps it alive through the access. */
+    emitBytesReceiver(receiver, following) {
+        if (receiver.kind === "varRef" &&
+            following.every((operand) => this.isStableBytesOperand(operand, receiver.localId))) {
+            const b = this.binding(receiver.localId);
+            if (b.kind !== "boxed") {
+                const value = this.B.tmp();
+                this.B.line(`${value} = load ptr, ptr ${b.slot}`);
+                return { name: value, type: receiver.type };
+            }
+        }
+        return this.emitExpr(receiver);
+    }
+    /** Load a canonical integer-loop induction value for a direct index use.
+     * Other expression shapes retain ordinary f64 evaluation. */
+    emitIntegerLoopIndex(expr) {
+        if (expr.kind !== "varRef")
+            return null;
+        const slot = this.integerLoopBindings.get(expr.localId);
+        if (slot === undefined)
+            return null;
+        const index = this.B.tmp();
+        this.B.line(`${index} = load i64, ptr ${slot}`);
+        return index;
+    }
+    /** Bounds-check a typed-array element index without an out-of-line call
+     * on the valid path. The range test rejects NaN/infinity before fptoui;
+     * the integer round trip then rejects fractions. The error block retains
+     * the runtime's exact trap text. Leaves the builder in the valid block. */
+    emitBytesIndex(receiver, index, integerIndex = false) {
+        const B = this.B;
+        const lenPtr = B.tmp();
+        const len = B.tmp();
+        B.line(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
+        B.line(`${len} = load i64, ptr ${lenPtr}`);
+        if (integerIndex) {
+            const inRange = B.tmp();
+            B.line(`${inRange} = icmp ult i64 ${index}, ${len}`);
+            const invalid = B.newLabel("bytes.index.invalid");
+            const valid = B.newLabel("bytes.index.valid");
+            B.condBr(inRange, valid, invalid);
+            B.startBlock(invalid);
+            const indexF64 = B.tmp();
+            B.line(`${indexF64} = uitofp i64 ${index} to double`);
+            this.declare(`declare double @scr_bytes_get(ptr, double)`);
+            B.line(`call double @scr_bytes_get(ptr ${receiver}, double ${indexF64})`);
+            B.terminate("unreachable");
+            B.startBlock(valid);
+            return index;
+        }
+        const lenF64 = B.tmp();
+        const nonnegative = B.tmp();
+        const belowLen = B.tmp();
+        const inRange = B.tmp();
+        B.line(`${lenF64} = uitofp i64 ${len} to double`);
+        B.line(`${nonnegative} = fcmp oge double ${index}, ${f64Lit(0)}`);
+        B.line(`${belowLen} = fcmp olt double ${index}, ${lenF64}`);
+        B.line(`${inRange} = and i1 ${nonnegative}, ${belowLen}`);
+        const rangeOk = B.newLabel("bytes.index.range");
+        const invalid = B.newLabel("bytes.index.invalid");
+        const valid = B.newLabel("bytes.index.valid");
+        B.condBr(inRange, rangeOk, invalid);
+        B.startBlock(rangeOk);
+        const idx = B.tmp();
+        const roundTrip = B.tmp();
+        const integral = B.tmp();
+        B.line(`${idx} = fptoui double ${index} to i64`);
+        B.line(`${roundTrip} = uitofp i64 ${idx} to double`);
+        B.line(`${integral} = fcmp oeq double ${roundTrip}, ${index}`);
+        B.condBr(integral, valid, invalid);
+        B.startBlock(invalid);
+        this.declare(`declare double @scr_bytes_get(ptr, double)`);
+        B.line(`call double @scr_bytes_get(ptr ${receiver}, double ${index})`);
+        B.terminate("unreachable");
+        B.startBlock(valid);
+        return idx;
+    }
+    /** Load the raw data pointer from ScrBytes after the bounds check. */
+    emitBytesData(receiver) {
+        const p = this.B.tmp();
+        const data = this.B.tmp();
+        this.B.line(`${p} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 3`);
+        this.B.line(`${data} = load ptr, ptr ${p}`);
+        return data;
+    }
+    /** Static typed-array length/byteLength load. */
+    emitBytesLength(elem, receiver, bytes) {
+        const B = this.B;
+        const p = B.tmp();
+        const len = B.tmp();
+        B.line(`${p} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
+        B.line(`${len} = load i64, ptr ${p}`);
+        const count = bytes && elem !== "u8" ? B.tmp() : len;
+        if (count !== len)
+            B.line(`${count} = shl i64 ${len}, 2`);
+        const out = B.tmp();
+        B.line(`${out} = uitofp i64 ${count} to double`);
+        return { name: out, type: F64 };
+    }
+    /** Kind-specialized typed-array load. */
+    emitBytesGet(elem, receiver, index, integerIndex = false) {
+        const B = this.B;
+        const idx = this.emitBytesIndex(receiver, index, integerIndex);
+        const data = this.emitBytesData(receiver);
+        const p = B.tmp();
+        if (elem === "u8") {
+            const raw = B.tmp();
+            const wide = B.tmp();
+            const out = B.tmp();
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`${raw} = load i8, ptr ${p}, align 1`);
+            B.line(`${wide} = zext i8 ${raw} to i32`);
+            B.line(`${out} = uitofp i32 ${wide} to double`);
+            return { name: out, type: F64 };
+        }
+        if (elem === "f32") {
+            const raw = B.tmp();
+            const out = B.tmp();
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`${raw} = load float, ptr ${p}, align 1`);
+            B.line(`${out} = fpext float ${raw} to double`);
+            return { name: out, type: F64 };
+        }
+        const raw = B.tmp();
+        const out = B.tmp();
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`${raw} = load i32, ptr ${p}, align 1`);
+        B.line(`${out} = ${elem === "i32" ? "sitofp" : "uitofp"} i32 ${raw} to double`);
+        return { name: out, type: F64 };
+    }
+    /** ToUint32/ToInt32 coercion with the overwhelmingly common finite,
+     * exactly-representable JS-number range on a cast-only path. Exceptional
+     * and huge values remain inline in the program TU so unrelated runtime
+     * binaries do not acquire another exported helper. */
+    emitBytesU32(value) {
+        const B = this.B;
+        const aboveMin = B.tmp();
+        const belowMax = B.tmp();
+        const fast = B.tmp();
+        B.line(`${aboveMin} = fcmp oge double ${value}, ${f64Lit(-9007199254740992)}`);
+        B.line(`${belowMax} = fcmp ole double ${value}, ${f64Lit(9007199254740992)}`);
+        B.line(`${fast} = and i1 ${aboveMin}, ${belowMax}`);
+        const fastLabel = B.newLabel("bytes.coerce.fast");
+        const slowLabel = B.newLabel("bytes.coerce.slow");
+        const done = B.newLabel("bytes.coerce.done");
+        B.condBr(fast, fastLabel, slowLabel);
+        B.startBlock(fastLabel);
+        const signed = B.tmp();
+        const fastU32 = B.tmp();
+        B.line(`${signed} = fptosi double ${value} to i64`);
+        B.line(`${fastU32} = trunc i64 ${signed} to i32`);
+        B.br(done);
+        B.startBlock(slowLabel);
+        const ordered = B.tmp();
+        const belowInf = B.tmp();
+        const aboveNegInf = B.tmp();
+        const finiteRange = B.tmp();
+        const finite = B.tmp();
+        B.line(`${ordered} = fcmp ord double ${value}, ${value}`);
+        B.line(`${belowInf} = fcmp olt double ${value}, ${F64_INF}`);
+        B.line(`${aboveNegInf} = fcmp ogt double ${value}, ${f64Lit(-Infinity)}`);
+        B.line(`${finiteRange} = and i1 ${belowInf}, ${aboveNegInf}`);
+        B.line(`${finite} = and i1 ${ordered}, ${finiteRange}`);
+        const finiteLabel = B.newLabel("bytes.coerce.finite");
+        const nonfiniteLabel = B.newLabel("bytes.coerce.nonfinite");
+        const slowDone = B.newLabel("bytes.coerce.slow.done");
+        B.condBr(finite, finiteLabel, nonfiniteLabel);
+        B.startBlock(finiteLabel);
+        this.declare(`declare double @llvm.trunc.f64(double)`);
+        const truncated = B.tmp();
+        const residue = B.tmp();
+        const negative = B.tmp();
+        const wrapped = B.tmp();
+        const normalized = B.tmp();
+        const finiteU32 = B.tmp();
+        B.line(`${truncated} = call double @llvm.trunc.f64(double ${value})`);
+        B.line(`${residue} = frem double ${truncated}, ${f64Lit(4294967296)}`);
+        B.line(`${negative} = fcmp olt double ${residue}, ${f64Lit(0)}`);
+        B.line(`${wrapped} = fadd double ${residue}, ${f64Lit(4294967296)}`);
+        B.line(`${normalized} = select i1 ${negative}, double ${wrapped}, double ${residue}`);
+        B.line(`${finiteU32} = fptoui double ${normalized} to i32`);
+        B.br(slowDone);
+        B.startBlock(nonfiniteLabel);
+        B.br(slowDone);
+        B.startBlock(slowDone);
+        const slowU32 = B.tmp();
+        B.line(`${slowU32} = phi i32 [ ${finiteU32}, %${finiteLabel} ], [ 0, %${nonfiniteLabel} ]`);
+        B.br(done);
+        B.startBlock(done);
+        const out = B.tmp();
+        B.line(`${out} = phi i32 [ ${fastU32}, %${fastLabel} ], [ ${slowU32}, %${slowDone} ]`);
+        return out;
+    }
+    /** Kind-specialized typed-array store. */
+    emitBytesSet(elem, receiver, index, value, integerIndex = false) {
+        const B = this.B;
+        const idx = this.emitBytesIndex(receiver, index, integerIndex);
+        const stored = elem === "f32" ? null : this.emitBytesU32(value);
+        const data = this.emitBytesData(receiver);
+        const p = B.tmp();
+        if (elem === "u8") {
+            const byte = B.tmp();
+            B.line(`${byte} = trunc i32 ${stored} to i8`);
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`store i8 ${byte}, ptr ${p}, align 1`);
+            return;
+        }
+        if (elem === "f32") {
+            const narrowed = B.tmp();
+            B.line(`${narrowed} = fptrunc double ${value} to float`);
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`store float ${narrowed}, ptr ${p}, align 1`);
+            return;
+        }
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`store i32 ${stored}, ptr ${p}, align 1`);
+    }
     /** The bytesIntrinsic surface (emit-exprs.ts's switch, .ll flavored).
      * Receiver and args are borrowed frame temps; string/bytes results come
      * back +1. The MAY_THROW methods get the standard pending check after
@@ -8672,18 +9114,31 @@ class LlEmitter {
                 ? call("scr_bytes_read_var", "double (ptr, double, double, i1 zeroext, i1 zeroext)", `ptr ${r0.name}, double ${rest[0].name}, double ${rest[1].name}, i1 ${spec.sign}, i1 ${spec.le}`, false, true)
                 : call("scr_bytes_write_var", "double (ptr, double, double, double, i1 zeroext, i1 zeroext)", `ptr ${r0.name}, double ${rest[0].name}, double ${rest[1].name}, double ${rest[2].name}, i1 ${spec.sign}, i1 ${spec.le}`, false, true);
         }
-        const r = this.emitExpr(e.receiver);
-        const args = e.args.map((a) => this.emitExpr(a));
         const method = e.method;
+        const directElementAccess = method === "length" || method === "byteLength" || method === "get";
+        const r = directElementAccess
+            ? this.emitBytesReceiver(e.receiver, e.args)
+            : this.emitExpr(e.receiver);
+        const integerIndex = method === "get" ? this.emitIntegerLoopIndex(e.args[0]) : null;
+        const args = integerIndex === null ? e.args.map((a) => this.emitExpr(a)) : [];
         const NAN = f64Lit(NaN);
         switch (method) {
             case "length":
-                return call("scr_bytes_len", "double (ptr)", `ptr ${r.name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic length on non-bytes");
+                }
+                return this.emitBytesLength(e.receiver.type.elem, r.name, false);
             case "byteLength":
-                return call("scr_bytes_byte_len", "double (ptr)", `ptr ${r.name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic byteLength on non-bytes");
+                }
+                return this.emitBytesLength(e.receiver.type.elem, r.name, true);
             case "get":
                 // Any invalid index traps (the array runtime's discipline).
-                return call("scr_bytes_get", "double (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic get on non-bytes");
+                }
+                return this.emitBytesGet(e.receiver.type.elem, r.name, integerIndex ?? args[0].name, integerIndex !== null);
             case "slice":
                 return call("scr_bytes_slice", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}`, true, false);
             case "subarray":
@@ -8702,21 +9157,26 @@ class LlEmitter {
                 // dst.set(src, offset?) — void; throws Node's RangeError on
                 // overflow.
                 return call("scr_bytes_set_from", "void (ptr, ptr, double)", `ptr ${r.name}, ptr ${args[0].name}, double ${args[1]?.name ?? f64Lit(0)}`, false, true);
-            case "toString": {
+            case "toString":
+            case "toStringVar": {
                 // The encoding arg is always present (the frontend completes an
-                // omitted one to "utf8"). Never throws; +1 string. Range forms:
-                // [enc, start] decodes to the buffer's end (the element count —
-                // r->len in the C spelling); [enc, start, end] clamps.
+                // omitted one to "utf8"). The runtime-valued form validates and
+                // may throw ERR_UNKNOWN_ENCODING; the literal form is canonical
+                // and cannot throw. Both return +1. Range forms: [enc, start]
+                // decode to the buffer's end (the element count — r->len in the C
+                // spelling); [enc, start, end] clamps.
+                const checked = method === "toStringVar";
+                const stem = checked ? "scr_bytes_to_str_checked" : "scr_bytes_to_str";
                 if (e.args.length === 3) {
-                    return call("scr_bytes_to_str_range", "ptr (ptr, ptr, double, double)", `ptr ${r.name}, ptr ${args[0].name}, double ${args[1].name}, double ${args[2].name}`, true, false);
+                    return call(`${stem}_range`, "ptr (ptr, ptr, double, double)", `ptr ${r.name}, ptr ${args[0].name}, double ${args[1].name}, double ${args[2].name}`, true, checked);
                 }
                 if (e.args.length === 2) {
                     this.declare(`declare double @scr_bytes_len(ptr)`);
                     const len = B.tmp();
                     B.line(`${len} = call double @scr_bytes_len(ptr ${r.name})`);
-                    return call("scr_bytes_to_str_range", "ptr (ptr, ptr, double, double)", `ptr ${r.name}, ptr ${args[0].name}, double ${args[1].name}, double ${len}`, true, false);
+                    return call(`${stem}_range`, "ptr (ptr, ptr, double, double)", `ptr ${r.name}, ptr ${args[0].name}, double ${args[1].name}, double ${len}`, true, checked);
                 }
-                return call("scr_bytes_to_str", "ptr (ptr, ptr)", `ptr ${r.name}, ptr ${args[0].name}`, true, false);
+                return call(stem, "ptr (ptr, ptr)", `ptr ${r.name}, ptr ${args[0].name}`, true, checked);
             }
             case "equals":
                 return call("scr_bytes_equals", "zeroext i1 (ptr, ptr)", `ptr ${r.name}, ptr ${args[0].name}`, false, false);
@@ -8845,7 +9305,14 @@ class LlEmitter {
             case "replaceAll":
                 return fallible("scr_regex_replace_all", `ptr ${r.name}, ptr ${args[0].name}, ptr ${args[1].name}`);
             case "split":
-                return fallible("scr_regex_split", `ptr ${r.name}, ptr ${args[0].name}`);
+                this.declare(`declare ptr @scr_regex_split_limit(ptr, ptr, double)`);
+                {
+                    const t = B.tmp();
+                    B.line(`${t} = call ptr @scr_regex_split_limit(ptr ${r.name}, ptr ${args[0].name}, double ${args[1].name})`);
+                    const out = this.own({ name: t, type: e.type });
+                    this.emitPendingCheck();
+                    return out;
+                }
             case "test": {
                 this.declare(`declare zeroext i1 @scr_regex_test(ptr, ptr)`);
                 const t = B.tmp();
@@ -9383,9 +9850,14 @@ class LlEmitter {
                 for (const field of fields) {
                     const index = shape.fields.indexOf(field) + 1;
                     const fieldPtr = B.tmp();
-                    const fieldValue = B.tmp();
+                    let fieldValue = B.tmp();
                     B.line(`${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`);
                     B.line(`${fieldValue} = load ${llFieldType(field.type)}, ptr ${fieldPtr}`);
+                    if (llFieldType(field.type) === "i8") {
+                        const boolValue = B.tmp();
+                        B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
+                        fieldValue = boolValue;
+                    }
                     const boxed = this.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
                     B.line(`call void @scr_dyn_arr_push(ptr ${out}, ptr ${boxed})`);
                 }
@@ -9406,9 +9878,14 @@ class LlEmitter {
                 for (const field of fields) {
                     const index = shape.fields.indexOf(field) + 1;
                     const fieldPtr = B.tmp();
-                    const fieldValue = B.tmp();
+                    let fieldValue = B.tmp();
                     B.line(`${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`);
                     B.line(`${fieldValue} = load ${llFieldType(field.type)}, ptr ${fieldPtr}`);
+                    if (llFieldType(field.type) === "i8") {
+                        const boolValue = B.tmp();
+                        B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
+                        fieldValue = boolValue;
+                    }
                     const boxed = this.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
                     B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${this.cstr(field.name)}, i64 ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
                 }
@@ -9592,6 +10069,71 @@ class LlEmitter {
         // Loop liveness first (one table for generic and special shapes).
         if (USES_TIMERS_LIB_FNS.has(e.fn))
             this.usesTimers = true;
+        if (e.fn === "process.stdoutWriteBytesCb" || e.fn === "process.stderrWriteBytesCb") {
+            // All arguments evaluate before bytes are submitted. The callback
+            // then moves into the next-tick entry and its error-first adapter
+            // constructs Node's success `null` argument when the tick fires.
+            this.usesTimers = true;
+            const args = e.args.map((a) => this.emitExpr(a));
+            const cbT = e.args[2].type;
+            if (cbT.kind !== "func")
+                throw new Error("llvm emitter bug: process write callback not a func");
+            this.moveTemp(args[2]);
+            const adapter = this.fsRenameThunkFor(cbT);
+            const write = e.fn === "process.stdoutWriteBytesCb"
+                ? "scr_process_stdout_write_bytes"
+                : "scr_process_stderr_write_bytes";
+            this.declare(`declare zeroext i1 @${write}(ptr, ptr)`);
+            this.declare(`declare void @scr_process_write_callback(ptr, ptr)`);
+            const out = B.tmp();
+            B.line(`${out} = call i1 @${write}(ptr ${args[0].name}, ptr ${args[1].name})`);
+            B.line(`call void @scr_process_write_callback(ptr ${args[2].name}, ptr @${adapter})`);
+            return { name: out, type: e.type };
+        }
+        if (e.fn === "fs.renameCb") {
+            // The callback MOVES into the next-turn operation. Its emitted
+            // adapter materializes the callback's Error | null union (or the
+            // checkJs dyn argument) from the runtime's borrowed ScrError.
+            this.usesTimers = true;
+            const args = e.args.map((a) => this.emitExpr(a));
+            const cbT = e.args[2].type;
+            if (cbT.kind !== "func")
+                throw new Error("llvm emitter bug: fs.rename callback not a func");
+            this.moveTemp(args[2]);
+            const adapter = this.fsRenameThunkFor(cbT);
+            this.declare(`declare void @scr_fs_rename_async(ptr, ptr, ptr, ptr)`);
+            B.line(`call void @scr_fs_rename_async(ptr ${args[0].name}, ptr ${args[1].name}, ptr ${args[2].name}, ptr @${adapter})`);
+            return { name: "", type: e.type };
+        }
+        if (e.fn === "fileHandle.read" || e.fn === "fileHandle.writeBytes" || e.fn === "fileHandle.writeStr") {
+            if (e.type.kind !== "promise" || e.type.inner.kind !== "record") {
+                throw new Error(`llvm emitter bug: ${e.fn} result`);
+            }
+            const args = e.args.map((a) => this.emitExpr(a));
+            const sym = e.fn === "fileHandle.read"
+                ? "scr_file_handle_read"
+                : e.fn === "fileHandle.writeBytes"
+                    ? "scr_file_handle_write_bytes"
+                    : "scr_file_handle_write_str";
+            const tail = e.fn === "fileHandle.writeStr"
+                ? "ptr, ptr, double, ptr"
+                : "ptr, ptr, double, double, double, i1 zeroext";
+            this.declare(`declare double @${sym}(${tail})`);
+            const count = B.tmp();
+            B.line(`${count} = call double @${sym}(${args.map((a) => `${this.llType(a.type)} ${a.name}`).join(", ")})`);
+            const inner = e.type.inner;
+            const rec = B.tmp();
+            B.line(`${rec} = call ptr @${mangleRecordNew(inner.shapeId)}()`);
+            const countField = e.fn === "fileHandle.read" ? "bytesRead" : "bytesWritten";
+            this.storeField(this.recordFieldPtr(rec, inner.shapeId, countField).ptr, F64, count);
+            const payload = this.retainValue(args[1].name, e.args[1].type);
+            B.line(`store ptr ${payload}, ptr ${this.recordFieldPtr(rec, inner.shapeId, "buffer").ptr}`);
+            const rc = vAdapters(this, inner);
+            this.declare(`declare ptr @scr_promise_settled_ref(ptr, ptr, ptr, ptr)`);
+            const result = B.tmp();
+            B.line(`${result} = call ptr @scr_promise_settled_ref(ptr ${rec}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, inner)})`);
+            return this.own({ name: result, type: e.type });
+        }
         if (e.fn === "fetch.responseText" || e.fn === "fetch.responseBytes") {
             if (e.type.kind !== "promise") {
                 throw new Error(`llvm emitter bug: ${e.fn} result`);