@scriptc/compiler 0.0.7 → 0.0.9

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,14 @@ 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.readFileSyncBuf": "scr_fs_read_file_bytes",
     "fs.readFileSyncBytes": "scr_fs_read_file_bytes",
     "fs.writeFileSyncBytes": "scr_fs_write_file_bytes",
@@ -376,6 +386,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 +495,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",
@@ -542,6 +557,8 @@ const LIB_FN_SYMS = {
     // (option/DataClone/cycle errors), and new RegExp's eager compile
     // (catchable SyntaxError) — all may-throw generics over the DOM.
     "dyn.objKeys": "scr_dyn_obj_keys",
+    "dyn.hasOwn": "scr_dyn_has_own",
+    "dyn.assign": "scr_dyn_assign",
     "dyn.objValues": "scr_dyn_obj_values",
     "dyn.objEntries": "scr_dyn_obj_entries",
     "dyn.structuredClone": "scr_structured_clone",
@@ -584,6 +601,7 @@ 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",
     "http.createServer", "http.createServerEmpty",
@@ -638,6 +656,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 } —
@@ -1013,7 +1043,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)`);
@@ -1023,7 +1053,7 @@ class LlEmitter {
                 this.declare(`declare ptr @scr_library_str_in(ptr, i64)`);
             }
             if (this.mod.lib.exports.some((e) => e.params.includes("bytes"))) {
-                this.declare(`declare ptr @scr_library_bytes_in(ptr, i64)`);
+                this.declare(`declare ptr @scr_library_bytes_in(ptr, i64, ptr)`);
             }
             if (this.mod.lib.exports.some((e) => e.returns === "string")) {
                 this.declare(`declare void @scr_library_str_out(ptr, ptr, ptr)`);
@@ -1257,6 +1287,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
@@ -1266,7 +1335,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
@@ -1277,15 +1346,23 @@ 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
+                // structured trap-teaching form (0x01 text 0x1F SC4012 0x1F symbol
+                // [0x1F remediation]) — the same bytes the C emission passes, so
+                // the sink message is emission-invariant by construction.
+                const trapBytes = Buffer.byteLength(e.inboundBytesTrap, "utf8");
+                out.push(`@sc_lib_bytes_trap_${e.symbol} = internal constant [${trapBytes + 1} x i8] c"${llStrBytes(e.inboundBytesTrap)}"`, ``);
+            }
             e.params.forEach((cls, i) => {
                 switch (cls) {
                     case "f64":
@@ -1319,7 +1396,7 @@ class LlEmitter {
                         break;
                     case "bytes":
                         params.push(`ptr %a${i}_ptr`, `i64 %a${i}_len`);
-                        body.push(`  %c${i} = call ptr @scr_library_bytes_in(ptr %a${i}_ptr, i64 %a${i}_len)`);
+                        body.push(`  %c${i} = call ptr @scr_library_bytes_in(ptr %a${i}_ptr, i64 %a${i}_len, ptr @sc_lib_bytes_trap_${e.symbol})`);
                         args.push(`ptr %c${i}`);
                         break;
                 }
@@ -2558,9 +2635,13 @@ class LlEmitter {
                 if (isRefCounted(v.type))
                     this.moveTemp(v);
                 const shape = this.recordShape(s.shapeId);
-                const iv = shape.indexValue;
+                // Signature-free shapes dispatch over their (one-typed) declared
+                // fields and TRAP on a miss (scr_record_key_miss — JS would add
+                // the property, which a monomorphic struct cannot); overflow
+                // shapes keep the map insert tail.
+                const iv = shape.indexValue ?? shape.fields[0]?.type;
                 if (!iv)
-                    throw new Error(`llvm emitter bug: keyed write on non-overflow shape ${s.shapeId}`);
+                    throw new Error(`llvm emitter bug: keyed write on field-free non-overflow shape ${s.shapeId}`);
                 const vAcc = iv.kind === "f64" ? "f64" : iv.kind === "bool" ? "bool" : "ref";
                 if (s.overflowOnly === true) {
                     // A LITERAL key naming no declared field: a plain overflow
@@ -2571,7 +2652,7 @@ class LlEmitter {
                 }
                 const join = B.newLabel("rks.j");
                 this.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
-                if (iv.kind === "dyn") {
+                if (iv.kind === "dyn" && shape.indexValue) {
                     // A dyn-valued shape (the C recordKeySetHelper's dyn arm,
                     // inline): declared keys VALIDATE the dyn value against the
                     // field's type first (dynCheck — a mismatched write throws the
@@ -2656,6 +2737,19 @@ class LlEmitter {
                     B.br(join);
                     B.startBlock(ln);
                 }
+                if (!shape.indexValue) {
+                    // The MISS on a fixed shape: release the moved-in value, throw
+                    // the catchable TypeError naming the key (scr_record_key_miss —
+                    // JS would add the property, the documented divergence).
+                    if (isRefCounted(iv))
+                        this.releaseValue(v.name, iv);
+                    this.declare(`declare void @scr_record_key_miss(ptr)`);
+                    B.line(`call void @scr_record_key_miss(ptr ${key.name})`);
+                    B.br(join);
+                    B.startBlock(join);
+                    this.emitPendingCheck();
+                    break;
+                }
                 const ovf = this.recordOvfPtr(obj.name, s.shapeId);
                 this.mapSet(ovf, "str", vAcc, key.name, v.name);
                 B.br(join);
@@ -3972,7 +4066,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;
                         }
@@ -4051,6 +4153,31 @@ class LlEmitter {
                 // TAG against its unit arms as the test. Pass-through shape: the
                 // result IS the left box. Narrowed shape: the single non-unit
                 // arm's payload extracts (+1 for ref kinds) and the box releases.
+                if (e.left.type.kind === "jsval") {
+                    // The island form: engine nullish test, lazy right (jsval).
+                    const l = this.emitExpr(e.left);
+                    this.moveTemp(l);
+                    this.declare(`declare zeroext i1 @scr_jsval_is_nullish(ptr)`);
+                    const slot = B.slot();
+                    B.entryAllocas.push(`${slot} = alloca ptr`);
+                    const isN = B.tmp();
+                    B.line(`${isN} = call zeroext i1 @scr_jsval_is_nullish(ptr ${l.name})`);
+                    const lu = B.newLabel("nulj.u");
+                    const lv = B.newLabel("nulj.v");
+                    const lj = B.newLabel("nulj.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);
@@ -5220,14 +5347,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]);
@@ -5400,6 +5531,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) {
@@ -5797,8 +5962,12 @@ class LlEmitter {
                     ? this.islandAdapter(fn.params.length, fn.ret.kind)
                     : this.islandTypedAdapter(fn);
                 this.declare(`declare ptr @scr_jsval_from_closure(ptr, i32, ptr)`);
+                // ISLAND-REST closures encode a NEGATIVE arity (the C emitter's
+                // rule): the wrapper hands the trailing slot the engine array of
+                // the surplus arguments.
+                const arity = fn.rest === true && fn.restAbi === "jsval" ? -fn.params.length : fn.params.length;
                 const t = B.tmp();
-                B.line(`${t} = call ptr @scr_jsval_from_closure(ptr ${v.name}, i32 ${fn.params.length}, ptr @${adapter})`);
+                B.line(`${t} = call ptr @scr_jsval_from_closure(ptr ${v.name}, i32 ${arity}, ptr @${adapter})`);
                 return this.own({ name: t, type: e.type });
             }
             default: {
@@ -5981,6 +6150,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)`);
@@ -5997,6 +6178,30 @@ class LlEmitter {
                 B.line(`${t} = call ptr @scr_jsval_obj_lit(i32 ${args.length / 2}, ptr ${pack})`);
                 return this.own({ name: t, type: e.type });
             }
+            case "tplStrings": {
+                const pack = argPack(args.map((x) => x.name));
+                this.declare(`declare ptr @scr_jsval_tpl_strings(i32, ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_jsval_tpl_strings(i32 ${args.length / 2}, ptr ${pack})`);
+                return this.own({ name: t, type: e.type });
+            }
+            case "objSpread": {
+                this.declare(`declare ptr @scr_jsval_obj_spread(ptr, ptr)`);
+                return fallible(() => {
+                    const t = B.tmp();
+                    B.line(`${t} = call ptr @scr_jsval_obj_spread(ptr ${a(0)}, ptr ${a(1)})`);
+                    return t;
+                });
+            }
+            case "defineGetter": {
+                // Getter completion for an island literal (the C emitter's
+                // scr_jsval_define_getter shape): defines key a(1) on obj a(0)
+                // as an engine getter invoking a(2); answers the object (+1).
+                this.declare(`declare ptr @scr_jsval_define_getter(ptr, ptr, ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_jsval_define_getter(ptr ${a(0)}, ptr ${a(1)}, ptr ${a(2)})`);
+                return this.own({ name: t, type: e.type });
+            }
             case "arrLit": {
                 const pack = argPack(args.map((x) => x.name));
                 this.declare(`declare ptr @scr_jsval_arr_lit(i32, ptr)`);
@@ -6306,7 +6511,7 @@ class LlEmitter {
         d.push(`  %fnp = getelementptr inbounds %ScrClosure, ptr %c, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`);
         if (ret.async) {
             // The closure returns a +1 ScrPromise; from_promise takes ownership.
-            const tagN = { void: 0, f64: 1, bool: 2, string: 3, jsval: 4, json: 0 }[ret.tag];
+            const tagN = { void: 0, f64: 1, bool: 2, string: 3, jsval: 4, json: 0, dyn: 0 }[ret.tag];
             this.declare(`declare ptr @scr_jsval_from_promise(ptr, i32)`);
             d.push(`  %pr = call ptr %fn(${passed.join(", ")})`, `  %prn = icmp eq ptr %pr, null`, `  br i1 %prn, label %pnull, label %pok`, `pnull:`, `  ret ptr null`, `pok:`, `  %pj = call ptr @scr_jsval_from_promise(ptr %pr, i32 ${tagN})`, `  ret ptr %pj`);
         }
@@ -6331,6 +6536,13 @@ class LlEmitter {
                     this.declare(`declare void @scr_str_release(ptr)`);
                     d.push(`  %r = call ptr %fn(${passed.join(", ")})`, `  %rn = icmp eq ptr %r, null`, `  br i1 %rn, label %snull, label %sok`, `snull:`, `  ret ptr null`, `sok:`, `  %j = call ptr @scr_jsval_from_str(ptr %r)`, `  call void @scr_str_release(ptr %r)`, `  ret ptr %j`);
                     break;
+                case "dyn":
+                    // A checked-dynamic (+1 DOM) result: deep copy into the engine
+                    // (the jsMarshal dyn rule); NULL is the throw-path dummy.
+                    this.declare(`declare ptr @scr_jsval_from_dyn(ptr)`);
+                    this.declare(`declare void @scr_dyn_release(ptr)`);
+                    d.push(`  %r = call ptr %fn(${passed.join(", ")})`, `  %rn = icmp eq ptr %r, null`, `  br i1 %rn, label %dnull, label %dok`, `dnull:`, `  ret ptr null`, `dok:`, `  %j = call ptr @scr_jsval_from_dyn(ptr %r)`, `  call void @scr_dyn_release(ptr %r)`, `  ret ptr %j`);
+                    break;
                 case "json": {
                     // A JSON-safe composite return: the jsMarshal path — the type-
                     // directed serializer, then the engine's JSON parser (deep
@@ -8044,6 +8256,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;
@@ -8424,6 +8648,42 @@ 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.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
@@ -9655,6 +9915,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).