@scriptc/compiler 0.0.23 → 0.0.25

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",
@@ -174,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.
@@ -236,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.
@@ -246,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
@@ -355,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",
@@ -854,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
@@ -983,6 +1004,7 @@ class LlEmitter {
             case "url":
             case "searchParams":
             case "stats":
+            case "fileHandle":
             case "spawnRes":
             case "child":
             case "childStream":
@@ -2205,6 +2227,7 @@ class LlEmitter {
             case "url":
             case "searchParams":
             case "stats":
+            case "fileHandle":
             case "spawnRes":
             case "child":
             case "childStream":
@@ -2302,6 +2325,7 @@ class LlEmitter {
                         case "url":
                         case "searchParams":
                         case "stats":
+                        case "fileHandle":
                         case "spawnRes":
                         case "child":
                         case "childStream":
@@ -2636,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 = [];
@@ -2837,11 +2862,12 @@ class LlEmitter {
                 // 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 idx = this.emitExpr(s.index);
+                const integerIndex = this.emitIntegerLoopIndex(s.index);
+                const idx = integerIndex ?? this.emitExpr(s.index).name;
                 const v = this.emitExpr(s.value);
                 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.name, v.name);
+                this.emitBytesSet(s.arr.type.elem, arr.name, idx, v.name, integerIndex !== null);
                 break;
             }
             case "fieldSet":
@@ -3098,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");
@@ -3114,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);
@@ -3146,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": {
@@ -3629,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.
@@ -7834,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/
@@ -8139,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":
@@ -8211,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).
@@ -8270,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]);
@@ -8719,20 +8863,47 @@ class LlEmitter {
         }
         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) {
+    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(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
-        B.line(`${len} = load i64, ptr ${lenPtr}`);
         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}`);
@@ -8779,9 +8950,9 @@ class LlEmitter {
         return { name: out, type: F64 };
     }
     /** Kind-specialized typed-array load. */
-    emitBytesGet(elem, receiver, index) {
+    emitBytesGet(elem, receiver, index, integerIndex = false) {
         const B = this.B;
-        const idx = this.emitBytesIndex(receiver, index);
+        const idx = this.emitBytesIndex(receiver, index, integerIndex);
         const data = this.emitBytesData(receiver);
         const p = B.tmp();
         if (elem === "u8") {
@@ -8873,9 +9044,9 @@ class LlEmitter {
         return out;
     }
     /** Kind-specialized typed-array store. */
-    emitBytesSet(elem, receiver, index, value) {
+    emitBytesSet(elem, receiver, index, value, integerIndex = false) {
         const B = this.B;
-        const idx = this.emitBytesIndex(receiver, index);
+        const idx = this.emitBytesIndex(receiver, index, integerIndex);
         const stored = elem === "f32" ? null : this.emitBytesU32(value);
         const data = this.emitBytesData(receiver);
         const p = B.tmp();
@@ -8948,7 +9119,8 @@ class LlEmitter {
         const r = directElementAccess
             ? this.emitBytesReceiver(e.receiver, e.args)
             : this.emitExpr(e.receiver);
-        const args = e.args.map((a) => this.emitExpr(a));
+        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":
@@ -8966,7 +9138,7 @@ class LlEmitter {
                 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, args[0].name);
+                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":
@@ -8985,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);
@@ -9128,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();
@@ -9666,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})`);
                 }
@@ -9689,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})`);
                 }
@@ -9875,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`);