@scriptc/compiler 0.0.8 → 0.0.10

package/dist/backend/llvm/emitter.js

@@ -1,4 +1,4 @@
-import { canMarshalFuncIntoIsland, CAUGHT, F64, islandCallbackRet, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesProcessEvents, moduleUsesStream, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
+import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, islandCallbackRet, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesProcessEvents, moduleUsesStream, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.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";
@@ -60,6 +60,8 @@ const LIB_FN_SYMS = {
     "dyn.errInstanceof": "scr_dyn_err_instanceof",
     "num.toExponential": "scr_num_to_exponential",
     "num.toFixed0": "scr_num_to_fixed0",
+    "num.sameValue": "scr_num_same_value",
+    "intl.numFormatEnUs": "scr_intl_num_format_en_us",
     "number.isFinite": "scr_num_is_finite",
     "number.isNaN": "scr_num_is_nan",
     "number.isInteger": "scr_num_is_integer",
@@ -187,6 +189,19 @@ const LIB_FN_SYMS = {
     "buffer.concatLen": "scr_bytes_concat_len",
     "buffer.byteLenStr": "scr_bytes_byte_length_str",
     "buffer.isEncoding": "scr_bytes_is_encoding",
+    // The checked-dynamic compare/equals validators (scr_bytes_io.c):
+    // Node's argument ladders throw catchably (MAY_THROW_LIB_FNS).
+    "dyn.toStringCoerce": "scr_dyn_string_coerce_js",
+    "buffer.compareChk": "scr_buffer_compare_chk",
+    "bytes.equalsChk": "scr_bytes_equals_chk",
+    "bytes.compareChk": "scr_bytes_compare_chk",
+    "buffer.newStringFail": "scr_buffer_new_string_fail",
+    "fs.toUnixTimestamp": "scr_fs_to_unix_timestamp",
+    "fs.existsChk": "scr_fs_exists_async",
+    "fs.mkdtempSyncChk": "scr_fs_mkdtemp_sync_chk",
+    "net.connectAttempt": "scr_net_connect_attempt",
+    "fs.lchmodSyncChk": "scr_fs_lchmod_sync_chk",
+    "fsp.lchmodChk": "scr_fsp_lchmod_chk",
     "fs.readFileSyncBuf": "scr_fs_read_file_bytes",
     "fs.readFileSyncBytes": "scr_fs_read_file_bytes",
     "fs.writeFileSyncBytes": "scr_fs_write_file_bytes",
@@ -332,9 +347,10 @@ const LIB_FN_SYMS = {
     // ambient-this read never throw. The fs dyn read is the sync-fs story.
     "json.parse": "scr_json_parse",
     "dyn.keySet": "scr_dyn_key_set",
+    "dyn.iterPack": "scr_dyn_iter_pack",
     "dyn.defineProps": "scr_dyn_define_props",
     "dyn.typeof": "scr_dyn_typeof",
-    "dyn.toString": "scr_dyn_to_string",
+    "dyn.toString": "scr_dyn_to_string_method",
     "dyn.this": "scr_dyn_this_get",
     "insp.dyn": "scr_insp_dyn",
     "insp.dynS": "scr_insp_dyn_s",
@@ -376,6 +392,8 @@ const LIB_FN_SYMS = {
     "emitter.names": "scr_emitter_event_names",
     "emitter.listeners": "scr_emitter_listeners",
     "emitter.setMax": "scr_emitter_set_max",
+    "emitter.setMaxChk": "scr_emitter_set_max_chk",
+    "emitter.setDefaultMaxChk": "scr_emitter_set_default_max_chk",
     "emitter.getMax": "scr_emitter_get_max",
     "emitter.setDefaultMax": "scr_emitter_set_default_max",
     "emitter.getDefaultMax": "scr_emitter_get_default_max",
@@ -483,6 +501,9 @@ const LIB_FN_SYMS = {
     // generic shapes; the throwing members ride the pending check.
     "tp.setTimeout": "scr_tp_set_timeout",
     "tp.setImmediate": "scr_tp_set_immediate",
+    // stream/promises' finished form (+1 promise; may-throw pending check;
+    // the pipeline form needs the stream-array compound and emits below).
+    "sp.finished": "scr_sp_finished",
     "dc.channel": "scr_dc_channel",
     "dc.subscribe": "scr_dc_subscribe",
     "dc.unsubscribe": "scr_dc_unsubscribe",
@@ -544,6 +565,14 @@ const LIB_FN_SYMS = {
     "dyn.objKeys": "scr_dyn_obj_keys",
     "dyn.hasOwn": "scr_dyn_has_own",
     "dyn.assign": "scr_dyn_assign",
+    // variadic Object.assign: the source pack (push never throws; the
+    // spread flatten throws V8's spread-call TypeErrors) and the final
+    // left-to-right copy (ToObject TypeError on a nullish target).
+    "dyn.packPush": "scr_dyn_pack_push",
+    "dyn.packPushSpread": "scr_dyn_pack_push_spread",
+    "dyn.packPushSpreadIter": "scr_dyn_pack_push_spread_iter",
+    "dyn.assignAll": "scr_dyn_assign_all",
+    "dyn.objCreateNullProto": "scr_dyn_new_obj_null_proto",
     "dyn.objValues": "scr_dyn_obj_values",
     "dyn.objEntries": "scr_dyn_obj_entries",
     "dyn.structuredClone": "scr_structured_clone",
@@ -586,8 +615,10 @@ const USES_TIMERS_LIB_FNS = new Set([
     "stream.setTransform", "stream.setFlush",
     "process.activeResources",
     "stream.finished", "stream.finishedDyn", "stream.pipeline", "stream.pipelineDyn",
+    "sp.finished", "sp.pipeline",
     "net.listen", "net.listenCb", "net.listenOpts", "net.listenOptsCb",
-    "net.connect", "net.connectCb", "net.connectLookup",
+    "net.connect", "net.connectCb", "net.connectLookup", "net.connectAttempt",
+    "fs.existsChk",
     "http.createServer", "http.createServerEmpty",
     "http.request", "http.requestCb", "http.requestUrl", "http.requestUrlCb",
     "http.requestConn", "http.requestConnCb",
@@ -640,6 +671,18 @@ const DV_GET_KIND = {
     dvGetBigUint64Number: 8,
     dvGetBigInt64Number: 9,
 };
+/** ScrDataViewGet per dvSet* method (the setters reuse the getter kinds;
+ * no BIG setters exist). */
+const DV_SET_KIND = {
+    dvSetUint8: 0,
+    dvSetInt8: 1,
+    dvSetUint16: 2,
+    dvSetInt16: 3,
+    dvSetUint32: 4,
+    dvSetInt32: 5,
+    dvSetFloat32: 6,
+    dvSetFloat64: 7,
+};
 class LlEmitter {
     mod;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
@@ -1015,7 +1058,7 @@ class LlEmitter {
         // LIBRARY mode: the runtime entry points the generated library
         // symbols delegate to — declared before the extern block flushes.
         if (this.mod.lib !== undefined) {
-            this.declare(`declare void @scr_library_entry(i1 zeroext)`);
+            this.declare(`declare void @scr_library_entry(i1 zeroext, ptr)`);
             this.declare(`declare void @scr_library_reset()`);
             this.declare(`declare void @scr_library_check_exc()`);
             this.declare(`declare void @scr_library_set_sink(ptr, ptr)`);
@@ -1259,6 +1302,45 @@ class LlEmitter {
         const lib = this.mod.lib;
         const autoReset = lib.resultResetSymbol === null;
         const out = [``, `; ── library-mode entries (profile: ${lib.profileName}) ──`, ``];
+        // Every entry's prologue records its external symbol in the funnel's
+        // current-entry slot (structured trap-teaching field 2); the symbols
+        // live as internal constants, one per entry.
+        const symConst = (sym) => `@sc_lib_sym_${sym}`;
+        const emitSymConst = (sym) => {
+            out.push(`${symConst(sym)} = internal constant [${Buffer.byteLength(sym, "utf8") + 1} x i8] c"${llStrBytes(sym)}"`);
+        };
+        emitSymConst(lib.initSymbol);
+        if (lib.resultResetSymbol !== null)
+            emitSymConst(lib.resultResetSymbol);
+        if (lib.collectSymbol !== null)
+            emitSymConst(lib.collectSymbol);
+        for (const e of lib.exports)
+            emitSymConst(e.symbol);
+        out.push(``);
+        // The runtime detected-trap overlay table (scr_runtime.h declares it,
+        // the library trap funnel consults it): flat code/teaching/remediation
+        // triples, one per runtime trap code (SC4013–SC4019) the profile
+        // declares text for — the same data the C emission defines, so the
+        // funnel-assembled sink message is emission-invariant by construction.
+        // The empty table still defines the symbols the funnel links against.
+        const ovlCells = [];
+        lib.trapOverlays.forEach((o, i) => {
+            const cell = (name, text) => {
+                if (text === undefined) {
+                    ovlCells.push("ptr null");
+                    return;
+                }
+                const sym = `@sc_lib_ovl_${i}_${name}`;
+                out.push(`${sym} = internal constant [${Buffer.byteLength(text, "utf8") + 1} x i8] c"${llStrBytes(text)}"`);
+                ovlCells.push(`ptr ${sym}`);
+            };
+            cell("code", o.code);
+            cell("teach", o.teaching);
+            cell("rem", o.remediation);
+        });
+        out.push(ovlCells.length === 0
+            ? `@scr_library_trap_overlays = constant [1 x ptr] zeroinitializer`
+            : `@scr_library_trap_overlays = constant [${ovlCells.length} x ptr] [${ovlCells.join(", ")}]`, `@scr_library_trap_overlays_len = constant i64 ${lib.trapOverlays.length}`, ``);
         // The init entry: full deterministic reset-and-reevaluate. Program
         // globals release and zero first (run-once guards included), then the
         // runtime session reset, the error-vt interval stamps verbatim from
@@ -1268,7 +1350,7 @@ class LlEmitter {
             const zero = ty === "double" ? f64Lit(0) : ty === "ptr" ? "null" : "false";
             return `  store ${ty} ${zero}, ptr @${mangleGlobal(g.id)} ; ${g.name}`;
         });
-        out.push(`define void @${lib.initSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext true) ; init always resets the result arena`, ...globalReleaseLines("ci"), ...zeroStores, `  call void @scr_library_reset()`, ...stamps, `  call void @${mangleFunction(this.mod.entry)}()`, `  call void @scr_library_check_exc()`, `  ret void`, `}`, ``, `define void @${lib.sinkRegisterSymbol}(ptr %fn, ptr %ctx) ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_set_sink(ptr %fn, ptr %ctx)`, `  ret void`, `}`, ``);
+        out.push(`define void @${lib.initSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext true, ptr ${symConst(lib.initSymbol)}) ; init always resets the result arena`, ...globalReleaseLines("ci"), ...zeroStores, `  call void @scr_library_reset()`, ...stamps, `  call void @${mangleFunction(this.mod.entry)}()`, `  call void @scr_library_check_exc()`, `  ret void`, `}`, ``, `define void @${lib.sinkRegisterSymbol}(ptr %fn, ptr %ctx) ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_set_sink(ptr %fn, ptr %ctx)`, `  ret void`, `}`, ``);
         if (lib.identity !== undefined) {
             // Profile-declared identity getters (the ask-2 sidecar's boot-time
             // pairing fence): pure data returns with NO entry prologue — exempt
@@ -1279,14 +1361,14 @@ class LlEmitter {
             out.push(`define i64 @${lib.identity.buildIdSymbol}() ${FN_ATTRS} { ; identity getter build_id 0x${lib.identity.buildId}`, `entry:`, `  ret i64 ${buildId}`, `}`, ``, `define i32 @${lib.identity.abiVersionSymbol}() ${FN_ATTRS} { ; identity getter abi_version`, `entry:`, `  ret i32 ${lib.identity.abiVersion}`, `}`, ``);
         }
         if (lib.resultResetSymbol !== null) {
-            out.push(`define void @${lib.resultResetSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false)`, `  call void @scr_library_arena_reset()`, `  ret void`, `}`, ``);
+            out.push(`define void @${lib.resultResetSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false, ptr ${symConst(lib.resultResetSymbol)})`, `  call void @scr_library_arena_reset()`, `  ret void`, `}`, ``);
         }
         if (lib.collectSymbol !== null) {
-            out.push(`define void @${lib.collectSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false)`, `  call void @scr_library_collect() ; arena reset + a full cycle collection`, `  ret void`, `}`, ``);
+            out.push(`define void @${lib.collectSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false, ptr ${symConst(lib.collectSymbol)})`, `  call void @scr_library_collect() ; arena reset + a full cycle collection`, `  ret void`, `}`, ``);
         }
         for (const e of lib.exports) {
             const params = [];
-            const body = [`  call void @scr_library_entry(i1 zeroext ${autoReset ? "true" : "false"})`];
+            const body = [`  call void @scr_library_entry(i1 zeroext ${autoReset ? "true" : "false"}, ptr ${symConst(e.symbol)})`];
             const args = [];
             if (e.inboundBytesTrap !== undefined) {
                 // The bytes-in helper's trap message: the compiler-assembled
@@ -3999,7 +4081,15 @@ class LlEmitter {
                             const t = B.tmp();
                             B.line(`${a} = call double @scr_union_get_f64(ptr ${l.name})`);
                             B.line(`${b} = call double @scr_union_get_f64(ptr ${r.name})`);
-                            B.line(`${t} = fcmp oeq double ${a}, ${b}`);
+                            if (e.sameValue) {
+                                // Object.is's f64 compare: NaN equals NaN, +0 differs
+                                // from -0 — the runtime SameValue.
+                                this.declare(`declare zeroext i1 @scr_num_same_value(double, double)`);
+                                B.line(`${t} = call zeroext i1 @scr_num_same_value(double ${a}, double ${b})`);
+                            }
+                            else {
+                                B.line(`${t} = fcmp oeq double ${a}, ${b}`);
+                            }
                             B.line(`store i1 ${t}, ptr ${slot}`);
                             break;
                         }
@@ -4103,6 +4193,33 @@ class LlEmitter {
                     B.line(`${t} = load ptr, ptr ${slot}`);
                     return this.own({ name: t, type: e.type });
                 }
+                if (e.left.type.kind === "dyn") {
+                    // The checked-dynamic form: the runtime kind decides (UNDEF/
+                    // NULL take the default; a wrapped island value asks the
+                    // engine); the right runs lazily in its branch (already dyn).
+                    const l = this.emitExpr(e.left);
+                    this.moveTemp(l);
+                    this.declare(`declare zeroext i1 @scr_dyn_is_nullish(ptr)`);
+                    const slot = B.slot();
+                    B.entryAllocas.push(`${slot} = alloca ptr`);
+                    const isN = B.tmp();
+                    B.line(`${isN} = call zeroext i1 @scr_dyn_is_nullish(ptr ${l.name})`);
+                    const lu = B.newLabel("nuld.u");
+                    const lv = B.newLabel("nuld.v");
+                    const lj = B.newLabel("nuld.j");
+                    B.condBr(isN, lu, lv);
+                    B.startBlock(lu);
+                    this.releaseValue(l.name, e.left.type);
+                    this.emitBranchInto(slot, e.right);
+                    B.br(lj);
+                    B.startBlock(lv);
+                    B.line(`store ptr ${l.name}, ptr ${slot}`);
+                    B.br(lj);
+                    B.startBlock(lj);
+                    const t = B.tmp();
+                    B.line(`${t} = load ptr, ptr ${slot}`);
+                    return this.own({ name: t, type: e.type });
+                }
                 if (e.left.type.kind !== "union")
                     throw new Error("llvm emitter bug: nullish left is not a union");
                 const def = this.unionsById.get(e.left.type.unionId);
@@ -5272,14 +5389,18 @@ class LlEmitter {
                 }
                 if (e.name === "promise.reject") {
                     // A fresh promise rejected through the exception cell: the
-                    // %Error-rooted reason moves in as the cell's OBJ payload, and
-                    // reject_pending moves the cell into the promise (consumed
-                    // immediately — no pending check runs in between).
+                    // %Error-rooted reason moves in as the cell's OBJ payload (a
+                    // checked-dynamic reason rides the thrown-dyn REF representation
+                    // instead — identity flows to catch/unhandledRejection observers,
+                    // emitThrowValue's dyn arm), and reject_pending moves the cell
+                    // into the promise (consumed immediately — no pending check runs
+                    // in between).
                     if (e.type.kind !== "promise")
                         throw new Error("llvm emitter bug: promise.reject type");
                     const reasonT = e.args[0].type;
-                    if (reasonT.kind !== "object")
+                    if (reasonT.kind !== "object" && reasonT.kind !== "dyn") {
                         throw new Error("llvm emitter bug: promise.reject reason");
+                    }
                     this.declare(`declare ptr @scr_promise_new()`);
                     this.declare(`declare void @scr_promise_reject_pending(ptr)`);
                     const reason = this.emitExpr(e.args[0]);
@@ -5421,6 +5542,16 @@ class LlEmitter {
                 B.line(`${t} = call ptr @${conv}(${valTy} ${v.name})`);
                 return this.own({ name: t, type: e.type });
             }
+            case "dynFromJsval": {
+                // Island value → DOM: the by-reference wrap (scr_dyn_from_jsval
+                // retains the cell in; engine scalars normalize to native DOM
+                // kinds at wrap time). Operand borrowed, result +1, never throws.
+                const v = this.emitExpr(e.value);
+                this.declare(`declare ptr @scr_dyn_from_jsval(ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_dyn_from_jsval(ptr ${v.name})`);
+                return this.own({ name: t, type: e.type });
+            }
             case "caughtToDyn": {
                 // A catch binding flowing into an `unknown` slot: the snapshot's
                 // runtime kind converts through the interned helper (+1 fresh
@@ -5452,6 +5583,40 @@ class LlEmitter {
                 // boxed thunk builds its own typed copies. The callee's source
                 // spelling rides along for Node's "<name> is not a function".
                 const callee = this.emitExpr(e.callee);
+                if (e.spreads !== undefined && e.spreads.length > 0) {
+                    // The RUNTIME-ARITY form (`f(...args)`): one fresh DOM array
+                    // collects the arguments left-to-right — plain args move in
+                    // (push takes ownership), spread args FLATTEN (push_spread
+                    // retains elements in and throws V8's spread-call TypeError for
+                    // non-iterable DOM kinds, checked per spread — JS's
+                    // ArgumentListEvaluation order) — then apply calls through the
+                    // array's elements (borrowed, exactly scr_dyn_call).
+                    this.declare(`declare ptr @scr_dyn_new_arr()`);
+                    this.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
+                    this.declare(`declare void @scr_dyn_arr_push_spread(ptr, ptr, ptr)`);
+                    this.declare(`declare ptr @scr_dyn_apply(ptr, ptr, ptr)`);
+                    const spreadAt = new Map(e.spreads.map((s) => [s.arg, s.what]));
+                    const pack = B.tmp();
+                    B.line(`${pack} = call ptr @scr_dyn_new_arr()`);
+                    this.own({ name: pack, type: DYN });
+                    e.args.forEach((a, i) => {
+                        const v = this.emitExpr(a);
+                        const spreadWhat = spreadAt.get(i);
+                        if (spreadWhat !== undefined) {
+                            B.line(`call void @scr_dyn_arr_push_spread(ptr ${pack}, ptr ${v.name}, ptr ${this.cstr(spreadWhat)})`);
+                            this.emitPendingCheck();
+                        }
+                        else {
+                            this.moveTemp(v);
+                            B.line(`call void @scr_dyn_arr_push(ptr ${pack}, ptr ${v.name})`);
+                        }
+                    });
+                    const t = B.tmp();
+                    B.line(`${t} = call ptr @scr_dyn_apply(ptr ${callee.name}, ptr ${pack}, ptr ${this.cstr(e.calleeName)})`);
+                    const out = this.own({ name: t, type: e.type });
+                    this.emitPendingCheck();
+                    return out;
+                }
                 const args = e.args.map((a) => this.emitExpr(a));
                 let argsPtr = "null";
                 if (args.length > 0) {
@@ -5568,7 +5733,8 @@ class LlEmitter {
                 B.startBlock(lNotObj);
                 const isArr = B.tmp();
                 B.line(`${isArr} = icmp eq i32 ${kd}, ${DK.ARR}`);
-                B.condBr(isArr, lArr, lj);
+                const lNotArr = B.newLabel("dhk.na");
+                B.condBr(isArr, lArr, lNotArr);
                 B.startBlock(lArr);
                 if (e.key === "length") {
                     B.line(`store i1 true, ptr ${slot}`);
@@ -5583,9 +5749,20 @@ class LlEmitter {
                     B.line(`store i1 ${inR}, ptr ${slot}`);
                 }
                 B.br(lj);
+                // An ISLAND-held receiver fences loudly (Node asks the real
+                // engine object — `false` would be a silent wrong answer); the
+                // helper answers false for every other kind, so this arm is a
+                // plain unconditional call.
+                B.startBlock(lNotArr);
+                this.declare(`declare zeroext i1 @scr_dyn_isl_fence(ptr, ptr)`);
+                const fenced = B.tmp();
+                B.line(`${fenced} = call zeroext i1 @scr_dyn_isl_fence(ptr ${d.name}, ptr ${this.cstr("'in'")})`);
+                B.line(`store i1 ${fenced}, ptr ${slot}`);
+                B.br(lj);
                 B.startBlock(lj);
                 const raw = B.tmp();
                 B.line(`${raw} = load i1, ptr ${slot}`);
+                this.emitPendingCheck();
                 if (!e.negated)
                     return { name: raw, type: e.type };
                 const neg = B.tmp();
@@ -5665,13 +5842,18 @@ class LlEmitter {
                 }
                 else if (e.test === "error") {
                     // `u instanceof Error`: the DOM's error encoding — an object
-                    // carrying the reserved "%error" marker key.
+                    // carrying the reserved "%error" marker key — or a real engine
+                    // Error held by reference (the isl helper answers false for
+                    // every non-JSVAL kind, so the call is unconditional).
                     const kd = this.dynKind(d.name);
                     const isObj = B.tmp();
                     B.line(`${isObj} = icmp eq i32 ${kd}, ${DK.OBJ}`);
                     const slot = B.slot();
                     B.entryAllocas.push(`${slot} = alloca i1`);
-                    B.line(`store i1 false, ptr ${slot}`);
+                    this.declare(`declare zeroext i1 @scr_dyn_isl_is_error(ptr)`);
+                    const isl = B.tmp();
+                    B.line(`${isl} = call zeroext i1 @scr_dyn_isl_is_error(ptr ${d.name})`);
+                    B.line(`store i1 ${isl}, ptr ${slot}`);
                     const lObj = B.newLabel("dts.o");
                     const lj = B.newLabel("dts.j");
                     B.condBr(isObj, lObj, lj);
@@ -5705,13 +5887,33 @@ class LlEmitter {
                         }
                         return acc;
                     };
+                    // ISLAND-held nodes route the tests that depend on the engine's
+                    // answer through the scr_dyn_isl_* helpers (false on every
+                    // other kind — the calls stay unconditional and branch-free).
+                    const orIsl = (acc, helper, arg) => {
+                        this.declare(`declare zeroext i1 @${helper}(ptr${arg !== undefined ? ", ptr" : ""})`);
+                        const c = B.tmp();
+                        B.line(`${c} = call zeroext i1 @${helper}(ptr ${d.name}${arg !== undefined ? `, ptr ${arg}` : ""})`);
+                        const o = B.tmp();
+                        B.line(`${o} = or i1 ${acc}, ${c}`);
+                        return o;
+                    };
                     if (e.test === "nullish") {
                         test = oneOf([DK.UNDEF, DK.NULL]);
                     }
                     else if (e.test === "object") {
                         // `typeof v === "object"`: objects, arrays, bytes, native
-                        // handles, promises, AND null.
-                        test = oneOf([DK.OBJ, DK.ARR, DK.BYTES, DK.HANDLE, DK.PROMISE, DK.NULL]);
+                        // handles, promises, AND null — engine-held objects by the
+                        // engine's own typeof.
+                        test = orIsl(oneOf([DK.OBJ, DK.ARR, DK.BYTES, DK.HANDLE, DK.PROMISE, DK.NULL]), "scr_dyn_isl_typeof_is", this.cstr("object"));
+                    }
+                    else if (e.test === "array") {
+                        // Array.isArray: the DOM's array kind, or the engine's own
+                        // answer for an engine-held value.
+                        test = orIsl(oneOf([DK.ARR]), "scr_dyn_isl_is_array");
+                    }
+                    else if (e.test === "function") {
+                        test = orIsl(oneOf([DK.FUNC]), "scr_dyn_isl_typeof_is", this.cstr("function"));
                     }
                     else {
                         const kindOf = {
@@ -5721,8 +5923,6 @@ class LlEmitter {
                             undefined: DK.UNDEF,
                             null: DK.NULL,
                             bytes: DK.BYTES,
-                            array: DK.ARR,
-                            function: DK.FUNC,
                         };
                         test = oneOf([kindOf[e.test]]);
                     }
@@ -5834,6 +6034,13 @@ class LlEmitter {
                 return simple("scr_jsval_from_bool", "i1", false);
             case "string":
                 return simple("scr_jsval_from_str", "ptr", false);
+            case "dyn":
+                // A CHECKED-DYNAMIC (DOM) value entering the island: deep copy,
+                // data kinds only — boxed functions/handles/promises throw the
+                // catchable TypeError in the runtime, and a wrapped island value
+                // unwraps to the SAME engine value (the identity round trip).
+                // The C emitter's rule, mirrored.
+                return simple("scr_jsval_from_dyn", "ptr", true);
             case "bytes":
                 // A typed array crossing IN: a COPY (the boundary's copy stance).
                 return simple("scr_jsval_from_bytes", "ptr", true);
@@ -6037,6 +6244,18 @@ class LlEmitter {
                     return t;
                 });
             }
+            case "callSpread": {
+                // Spread application (`f(...pre, ...s)`): the prelude helper's
+                // real spread syntax — iterator protocols are the engine's own,
+                // the guards front-run V8's spread-call TypeError texts (the name
+                // literal is the spread expression's spelling).
+                this.declare(`declare ptr @scr_jsval_call_spread(ptr, ptr, ptr, ptr)`);
+                return fallible(() => {
+                    const t = B.tmp();
+                    B.line(`${t} = call ptr @scr_jsval_call_spread(ptr ${a(0)}, ptr ${a(1)}, ptr ${a(2)}, ptr ${nameSym()})`);
+                    return t;
+                });
+            }
             case "construct": {
                 const pack = argPack(args.slice(1).map((x) => x.name));
                 this.declare(`declare ptr @scr_jsval_construct(ptr, i32, ptr)`);
@@ -8131,6 +8350,18 @@ class LlEmitter {
                 // DataView getters: an omitted littleEndian is big-endian (the JS
                 // default). Throw Node's constant RangeError on a bad offset.
                 return call("scr_dataview_get", "double (ptr, double, i32, i1 zeroext)", `ptr ${r.name}, double ${args[0].name}, i32 ${DV_GET_KIND[method]}, i1 ${args[1]?.name ?? "false"}`, false, true);
+            case "dvSetUint8":
+            case "dvSetInt8":
+            case "dvSetUint16":
+            case "dvSetInt16":
+            case "dvSetUint32":
+            case "dvSetInt32":
+            case "dvSetFloat32":
+            case "dvSetFloat64":
+                // DataView setters: [offset, value, littleEndian?] — void; throw
+                // the getters' constant RangeError on a bad offset.
+                return call("scr_dataview_set", "void (ptr, double, double, i32, i1 zeroext)", `ptr ${r.name}, double ${args[0].name}, double ${args[1].name}, ` +
+                    `i32 ${DV_SET_KIND[method]}, i1 ${args[2]?.name ?? "false"}`, false, true);
             default: {
                 const _exhaustive = method;
                 void _exhaustive;
@@ -8511,6 +8742,90 @@ class LlEmitter {
         if (USES_TIMERS_LIB_FNS.has(e.fn))
             this.usesTimers = true;
         // The handful with non-generic shapes first.
+        if (e.fn === "error.argTypeThrow") {
+            // Always throws with the runtime-rendered Received tail (the
+            // error.nodeThrow dummy pattern). Borrows all three.
+            const an = this.emitExpr(e.args[0]);
+            const ex = this.emitExpr(e.args[1]);
+            const got = this.emitExpr(e.args[2]);
+            this.declare(`declare void @scr_throw_arg_type(ptr, ptr, ptr)`);
+            B.line(`call void @scr_throw_arg_type(ptr ${an.name}, ptr ${ex.name}, ptr ${got.name})`);
+            const ty = this.llType(e.type);
+            if (ty === "void") {
+                this.emitPendingCheck();
+                return { name: "", type: e.type };
+            }
+            const dummy = ty === "double" ? f64Lit(0) : ty === "i1" ? "false" : "null";
+            const out = this.own({ name: dummy, type: e.type });
+            this.emitPendingCheck();
+            return out;
+        }
+        if (e.fn === "error.propTypeThrow") {
+            // The property flavor of argTypeThrow — same always-throw shape.
+            const an = this.emitExpr(e.args[0]);
+            const ex = this.emitExpr(e.args[1]);
+            const got = this.emitExpr(e.args[2]);
+            this.declare(`declare void @scr_throw_prop_type(ptr, ptr, ptr)`);
+            B.line(`call void @scr_throw_prop_type(ptr ${an.name}, ptr ${ex.name}, ptr ${got.name})`);
+            const ty = this.llType(e.type);
+            if (ty === "void") {
+                this.emitPendingCheck();
+                return { name: "", type: e.type };
+            }
+            const dummy = ty === "double" ? f64Lit(0) : ty === "i1" ? "false" : "null";
+            const out = this.own({ name: dummy, type: e.type });
+            this.emitPendingCheck();
+            return out;
+        }
+        {
+            // The fs validation-ladder Chk forms that ALWAYS throw (a
+            // validation error or the trailing compiler-rendered fence): every
+            // argument is a ptr (dyns + the fence string), and the typed dummy
+            // is abandoned by the pending check's unwind.
+            const FS_CHK_THROW_SYMS = {
+                "fs.mkdtempChk": "scr_fs_mkdtemp_chk",
+                "fs.readFileChk": "scr_fs_read_file_chk",
+                "fs.opendirChk": "scr_fs_opendir_chk",
+                "fs.watchFileChk": "scr_fs_watch_file_chk",
+                "fs.lchmodChk": "scr_fs_lchmod_chk",
+                "fs.readChk": "scr_fs_read_chk",
+                "fs.streamOptsChk": "scr_fs_stream_opts_chk",
+                "net.connectOptsChk": "scr_net_connect_opts_chk",
+            };
+            const sym = FS_CHK_THROW_SYMS[e.fn];
+            if (sym !== undefined) {
+                const args = e.args.map((a) => this.emitExpr(a));
+                this.declare(`declare void @${sym}(${args.map(() => "ptr").join(", ")})`);
+                B.line(`call void @${sym}(${args.map((a) => `ptr ${a.name}`).join(", ")})`);
+                const ty = this.llType(e.type);
+                if (ty === "void") {
+                    this.emitPendingCheck();
+                    return { name: "", type: e.type };
+                }
+                const dummy = ty === "double" ? f64Lit(0) : ty === "i1" ? "false" : "null";
+                const out = this.own({ name: dummy, type: e.type });
+                this.emitPendingCheck();
+                return out;
+            }
+        }
+        if (e.fn === "error.nodeThrow") {
+            // The compiler-resolved Node-parity throw (always throws — the
+            // typed dummy is abandoned by the pending check's unwind).
+            const kind = this.emitExpr(e.args[0]);
+            const code = this.emitExpr(e.args[1]);
+            const msg = this.emitExpr(e.args[2]);
+            this.declare(`declare void @scr_throw_node_coded(double, ptr, ptr)`);
+            B.line(`call void @scr_throw_node_coded(double ${kind.name}, ptr ${code.name}, ptr ${msg.name})`);
+            const ty = this.llType(e.type);
+            if (ty === "void") {
+                this.emitPendingCheck();
+                return { name: "", type: e.type };
+            }
+            const dummy = ty === "double" ? f64Lit(0) : ty === "i1" ? "false" : "null";
+            const out = this.own({ name: dummy, type: e.type });
+            this.emitPendingCheck();
+            return out;
+        }
         if (e.fn === "global.undefRead") {
             // A declare-d const nothing defines: Node's catchable
             // ReferenceError at the access (always throws — the typed dummy is
@@ -9742,6 +10057,28 @@ class LlEmitter {
             this.emitPendingCheck();
             return out;
         }
+        if (e.fn === "sp.pipeline") {
+            // pipeline(count, s1..sn) settling a void promise: the stream list
+            // rides the callback form's stack array, no callback slot.
+            const countArg = e.args[0];
+            if (countArg.kind !== "numLit")
+                throw new Error(`llvm emitter bug: ${e.fn} count not a literal`);
+            const n = countArg.value;
+            const args = e.args.map((a) => this.emitExpr(a));
+            const arr = B.slot();
+            B.entryAllocas.push(`${arr} = alloca [${n} x ptr]`);
+            for (let i = 0; i < n; i++) {
+                const p = B.tmp();
+                B.line(`${p} = getelementptr inbounds [${n} x ptr], ptr ${arr}, i64 0, i64 ${i}`);
+                B.line(`store ptr ${args[1 + i].name}, ptr ${p}`);
+            }
+            const t = B.tmp();
+            this.declare(`declare ptr @scr_sp_pipeline(double, ptr)`);
+            B.line(`${t} = call ptr @scr_sp_pipeline(double ${f64Lit(n)}, ptr ${arr})`);
+            const out = this.own({ name: t, type: e.type });
+            this.emitPendingCheck();
+            return out;
+        }
         if (e.fn === "stream.pipeline" || e.fn === "stream.pipelineDyn") {
             // pipeline(count, s1..sn, cb): the destination answers +1. The
             // stream list rides a stack array (the C compound literal).