@scriptc/compiler 0.0.8 → 0.0.10

package/dist/backend/emission/emit-exprs.js

@@ -1,5 +1,5 @@
 import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, DYN, F64, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals } from "../../ir/nodes.js";
-import { boxAccess, BYTES_NUM_KIND_C, BYTES_NUM_VAR_C, bytesElemKindC, cDecl, cFnPtrCast, cNumberLiteral, cStringLiteral, cType, DV_GET_KIND_C, elemAccess, mapKeyAccess, mapKeyKindC, mapValKindC, retainCallC, vAdapters } from "./emit-types.js";
+import { boxAccess, BYTES_NUM_KIND_C, BYTES_NUM_VAR_C, bytesElemKindC, cDecl, cFnPtrCast, cNumberLiteral, cStringLiteral, cType, DV_GET_KIND_C, DV_SET_KIND_C, elemAccess, mapKeyAccess, mapKeyKindC, mapValKindC, retainCallC, vAdapters } from "./emit-types.js";
 import { mangleClassNew, mangleClassRetain, mangleClassStruct, mangleField, mangleFnClosure, mangleFunction, mangleGlobal, mangleLocal, mangleRecordNew, mangleRecordStruct, mangleVtStruct } from "../mangle.js";
 import { OVERFLOW_MEMBER } from "./emit-shapes.js";
 import { dynDestrCheckHelper, dynIterNHelper, dynKeyGetHelper } from "./emit-walkers.js";
@@ -489,6 +489,28 @@ export function emitExpr(E, e) {
                     E.currentFrame().push({ name, type: e.type });
                 return { name, type: e.type };
             }
+            if (e.left.type.kind === "dyn") {
+                // `a ?? b` on a checked-dynamic left: 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 = E.emitExpr(e.left);
+                E.moveTemp(l);
+                const name = `sc_t${E.tempCounter++}`;
+                E.line(`${cDecl(e.type, name)};`);
+                E.line(`if (scr_dyn_is_nullish(${l.name})) {`);
+                E.indent++;
+                E.releaseValue(l.name, e.left.type);
+                E.emitBranchInto(name, e.right);
+                E.indent--;
+                E.line(`} else {`);
+                E.indent++;
+                E.line(`${name} = ${l.name};`);
+                E.indent--;
+                E.line(`}`);
+                if (isRefCounted(e.type))
+                    E.currentFrame().push({ name, type: e.type });
+                return { name, type: e.type };
+            }
             if (e.left.type.kind !== "union")
                 throw new Error("emitter bug: nullish left is not a union");
             const def = E.unionsById.get(e.left.type.unionId);
@@ -1102,6 +1124,22 @@ export function emitExpr(E, e) {
                     E.emitPendingCheck();
                     return t;
                 }
+                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.
+                    const kind = DV_SET_KIND_C[method];
+                    E.line(`scr_dataview_set(${r.name}, ${args[0].name}, ${args[1].name}, ${kind}, ` +
+                        `${args[2]?.name ?? "false"});${E.srcComment(e.loc)}`);
+                    E.emitPendingCheck();
+                    return { name: "", type: e.type };
+                }
                 default: {
                     const _exhaustive = method;
                     void _exhaustive;
@@ -1573,6 +1611,13 @@ export function emitExpr(E, e) {
             }
             return E.newTemp(e.type, `${E.toDynHelper(v.type)}(${v.name})`);
         }
+        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 = E.emitExpr(e.value);
+            return E.newTemp(e.type, `scr_dyn_from_jsval(${v.name})`);
+        }
         case "dynCall": {
             // Calling a dyn value: args are already dyn (the lowering boxed or
             // converted them); everything is BORROWED by scr_dyn_call — the
@@ -1580,6 +1625,32 @@ export function emitExpr(E, e) {
             // with the frame as usual. The callee's source spelling rides
             // along for Node's "<name> is not a function" TypeError.
             const callee = E.emitExpr(e.callee);
+            const what = cStringLiteral(Buffer.from(e.calleeName, "utf8"));
+            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).
+                const spreadAt = new Map(e.spreads.map((s) => [s.arg, s.what]));
+                const pack = E.newTemp(DYN, "scr_dyn_new_arr()");
+                e.args.forEach((a, i) => {
+                    const v = E.emitExpr(a);
+                    const spreadWhat = spreadAt.get(i);
+                    if (spreadWhat !== undefined) {
+                        const w = cStringLiteral(Buffer.from(spreadWhat, "utf8"));
+                        E.line(`scr_dyn_arr_push_spread(${pack.name}, ${v.name}, ${w});`);
+                        E.emitPendingCheck();
+                    }
+                    else {
+                        E.moveTemp(v);
+                        E.line(`scr_dyn_arr_push(${pack.name}, ${v.name});`);
+                    }
+                });
+                return E.fallibleTemp(e.type, `scr_dyn_apply(${callee.name}, ${pack.name}, ${what})`);
+            }
             const args = e.args.map((a) => E.emitExpr(a));
             let argsExpr = "NULL";
             if (args.length > 0) {
@@ -1587,7 +1658,6 @@ export function emitExpr(E, e) {
                 E.line(`ScrDyn *${arr}[${args.length}] = { ${args.map((a) => a.name).join(", ")} };`);
                 argsExpr = arr;
             }
-            const what = cStringLiteral(Buffer.from(e.calleeName, "utf8"));
             return E.fallibleTemp(e.type, `scr_dyn_call(${callee.name}, ${argsExpr}, ${args.length}, ${what})`);
         }
         case "dynInvoke": {
@@ -1826,6 +1896,9 @@ export function emitExpr(E, e) {
         case "dynHasKey": {
             // `"k" in pkg`: a kind-guarded presence answer, computed against
             // the literal key at compile time — no allocation, borrowed box.
+            // An ISLAND-held receiver fences loudly (Node asks the real
+            // engine object — `false` would be a silent wrong answer), so
+            // the temp rides the fallible path.
             const d = E.emitExpr(e.value);
             const keyBytes = Buffer.from(e.key, "utf8");
             const keyLit = cStringLiteral(keyBytes);
@@ -1835,8 +1908,8 @@ export function emitExpr(E, e) {
                 : /^(0|[1-9][0-9]*)$/.test(e.key) && Number(e.key) <= Number.MAX_SAFE_INTEGER
                     ? `${d.name}->v.arr.len > ${e.key}`
                     : "false";
-            const test = `(${d.name}->kind == SCR_DYN_OBJ ? (${objTest}) : ${d.name}->kind == SCR_DYN_ARR ? (${arrTest}) : false)`;
-            return E.newTemp(e.type, e.negated ? `!${test}` : test);
+            const test = `(${d.name}->kind == SCR_DYN_OBJ ? (${objTest}) : ${d.name}->kind == SCR_DYN_ARR ? (${arrTest}) : scr_dyn_isl_fence(${d.name}, "'in'"))`;
+            return E.fallibleTemp(e.type, e.negated ? `!${test}` : test);
         }
         case "dynScalarEq": {
             // dyn vs scalar strict equality: kind test + payload compare.
@@ -1858,34 +1931,50 @@ export function emitExpr(E, e) {
         }
         case "dynTest": {
             // A pure kind compare on the DOM node — borrowed; only the truthy
-            // form also reads a scalar payload.
+            // form also reads a scalar payload. ISLAND-held nodes (the jsval
+            // kind — engine objects/arrays/functions only, scalars normalize
+            // at wrap time) route the tests that depend on the engine's
+            // answer through the scr_dyn_isl_* helpers (false on every other
+            // kind, so the calls stay unconditional); narrowing never changes
+            // representation (SEMANTICS.md).
             const d = E.emitExpr(e.value);
             const test = e.test === "nullish"
                 ? `(${d.name}->kind == SCR_DYN_UNDEF || ${d.name}->kind == SCR_DYN_NULL)`
                 : e.test === "object"
                     ? // `typeof v === "object"`: objects, arrays, bytes, native
-                        // handles, promises, AND null.
-                        `(${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE || ${d.name}->kind == SCR_DYN_NULL)`
+                        // handles, promises, AND null — engine-held objects by the
+                        // engine's own typeof.
+                        `(${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE || ${d.name}->kind == SCR_DYN_NULL || scr_dyn_isl_typeof_is(${d.name}, "object"))`
                     : e.test === "truthy"
                         ? // ToBoolean over the DOM: bool by value; number falsy for
                             // 0, -0 (== 0 in C), and NaN (self-inequality); string
                             // falsy when empty; obj/arr/bytes/func/handle always true;
-                            // the remaining kinds (undefined, null) always false.
-                            `(${d.name}->kind == SCR_DYN_BOOL ? ${d.name}->v.b : ${d.name}->kind == SCR_DYN_NUM ? (${d.name}->v.num == ${d.name}->v.num && ${d.name}->v.num != 0) : ${d.name}->kind == SCR_DYN_STR ? ${d.name}->v.str->len != 0 : (${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_FUNC || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE))`
+                            // JSVAL through the runtime's routed arm (the bigint 0n
+                            // edge); the remaining kinds (undefined, null) always false.
+                            `(${d.name}->kind == SCR_DYN_BOOL ? ${d.name}->v.b : ${d.name}->kind == SCR_DYN_NUM ? (${d.name}->v.num == ${d.name}->v.num && ${d.name}->v.num != 0) : ${d.name}->kind == SCR_DYN_STR ? ${d.name}->v.str->len != 0 : ${d.name}->kind == SCR_DYN_JSVAL ? scr_dyn_truthy(${d.name}) : (${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_FUNC || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE))`
                         : e.test === "error"
                             ? // `u instanceof Error`: the DOM's error encoding — an
                                 // object carrying the reserved "%error" marker key
-                                // (built by caughtToDyn for Error payloads).
-                                `(${d.name}->kind == SCR_DYN_OBJ && scr_dyn_obj_get(${d.name}, "%error", 6) != NULL)`
-                            : `${d.name}->kind == ${{ string: "SCR_DYN_STR", number: "SCR_DYN_NUM", boolean: "SCR_DYN_BOOL", undefined: "SCR_DYN_UNDEF", null: "SCR_DYN_NULL", bytes: "SCR_DYN_BYTES", array: "SCR_DYN_ARR", function: "SCR_DYN_FUNC" }[e.test]}`;
+                                // (built by caughtToDyn for Error payloads) — or a real
+                                // engine Error held by reference.
+                                `((${d.name}->kind == SCR_DYN_OBJ && scr_dyn_obj_get(${d.name}, "%error", 6) != NULL) || scr_dyn_isl_is_error(${d.name}))`
+                            : e.test === "array"
+                                ? // Array.isArray: the DOM's array kind, or the engine's
+                                    // own answer for an engine-held value.
+                                    `(${d.name}->kind == SCR_DYN_ARR || scr_dyn_isl_is_array(${d.name}))`
+                                : e.test === "function"
+                                    ? `(${d.name}->kind == SCR_DYN_FUNC || scr_dyn_isl_typeof_is(${d.name}, "function"))`
+                                    : `${d.name}->kind == ${{ string: "SCR_DYN_STR", number: "SCR_DYN_NUM", boolean: "SCR_DYN_BOOL", undefined: "SCR_DYN_UNDEF", null: "SCR_DYN_NULL", bytes: "SCR_DYN_BYTES" }[e.test]}`;
             return E.newTemp(e.type, e.negated ? `!(${test})` : test);
         }
         case "unionEq": {
-            // Strict equality of the ARM values via the per-union helper (tag
-            // compare + per-arm payload compare). Both boxes are borrowed.
+            // Strict equality (or Object.is's SameValue — the f64 arm's
+            // compare is the one difference) of the ARM values via the
+            // per-union helper (tag compare + per-arm payload compare). Both
+            // boxes are borrowed.
             const l = E.emitExpr(e.left);
             const r = E.emitExpr(e.right);
-            const call = `${E.unionEqHelper(e.unionId)}(${l.name}, ${r.name})`;
+            const call = `${E.unionEqHelper(e.unionId, e.sameValue)}(${l.name}, ${r.name})`;
             return E.newTemp(e.type, e.negated ? `!${call}` : call);
         }
         case "caughtTest": {
@@ -2145,13 +2234,20 @@ export function emitExpr(E, e) {
                     // member retains the value in); throws Node's TypeErrors on
                     // non-object receivers (may-throw seed set).
                     return finish(`scr_dyn_key_set(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "dyn.iterPack":
+                    // Destructuring pack over a dyn source: both borrowed, fresh
+                    // array +1; throws V8's destructuring TypeError on
+                    // non-iterable DOM kinds (may-throw seed set).
+                    return finish(`scr_dyn_iter_pack(${arg(0)}, ${arg(1)})`);
                 case "dyn.typeof":
                     // Bare typeof on a dyn value: the DOM kind's JS answer (+1).
                     return finish(`scr_dyn_typeof(${arg(0)})`);
                 case "dyn.toString":
                     // Receiver-kind-dispatched toString (+1); throws Node's
-                    // TypeError on undefined/null (may-throw seed set).
-                    return finish(`scr_dyn_to_string(${arg(0)}, ${arg(1)})`);
+                    // TypeError on undefined/null and the "is not a function"
+                    // TypeError on null-prototype dictionaries (may-throw seed
+                    // set) — args[2] carries the call's source spelling.
+                    return finish(`scr_dyn_to_string_method(${arg(0)}, ${arg(1)}, ${arg(2)})`);
                 case "fs.readFileSync":
                     // args[1] is the (always-"utf8") encoding: evaluated for
                     // JS-exact side-effect order, ignored by the runtime.
@@ -2440,6 +2536,13 @@ export function emitExpr(E, e) {
                     return finish(`scr_num_to_exponential(${arg(0)})`);
                 case "num.toFixed0":
                     return finish(`scr_num_to_fixed0(${arg(0)})`);
+                // Object.is over two numbers — SameValue on doubles. No throw.
+                case "num.sameValue":
+                    return finish(`scr_num_same_value(${arg(0)}, ${arg(1)})`);
+                // Intl.NumberFormat("en-US").format / toLocaleString("en-US")
+                // with default options (scr_lib.c). +1 string; no throw.
+                case "intl.numFormatEnUs":
+                    return finish(`scr_intl_num_format_en_us(${arg(0)})`);
                 // The URL surface (scr_url.c): construction and the two
                 // fileURLToPath receiver forms throw catchable TypeErrors
                 // (may-throw seed set); the getters are pure reads. Receivers
@@ -2991,6 +3094,15 @@ export function emitExpr(E, e) {
                 case "net.connect":
                     E.usesTimers = true; // a connecting/open socket holds the loop open
                     return finish(`scr_net_connect(${arg(0)}, ${arg(1)}, NULL)`);
+                case "net.connectAttempt":
+                    // The validated autoSelectFamilyAttemptTimeout form: Node's
+                    // range ladder runs first, the dial follows.
+                    E.usesTimers = true;
+                    return finish(`scr_net_connect_attempt(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "net.connectOptsChk":
+                    // The runtime option-bag ladder (always throws — a validation
+                    // error or the trailing fence; the error.nodeThrow dummy).
+                    return finish(`(scr_net_connect_opts_chk(${arg(0)}, ${arg(1)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 case "net.connectCb": {
                     E.usesTimers = true;
                     const cb = args[2];
@@ -3093,6 +3205,9 @@ export function emitExpr(E, e) {
                 case "dgram.sendBytes":
                     E.usesTimers = true;
                     return finish(`scr_dgram_send_bytes(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+                case "dgram.sendChk":
+                    E.usesTimers = true; // a validated send implicit-binds
+                    return finish(`scr_dgram_send_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)})`);
                 case "dgram.address": {
                     // The AddressInfo record, built here from runtime parts (the
                     // frontend pinned the {address, family, port} shape). The
@@ -3800,6 +3915,13 @@ export function emitExpr(E, e) {
                     // SNI answer serves; bad material is the construction-time
                     // print-and-die trap, like createServer's.
                     return finish(`scr_tls_create_secure_context((const char *)${arg(0)}->data, ${arg(0)}->len, (const char *)${arg(1)}->data, ${arg(1)}->len)`);
+                case "tls.createSecureContextDyn":
+                    // The runtime option-bag form: Node's typed validations, then
+                    // the pem walk (throws catchably on both ladders).
+                    return finish(`scr_tls_create_secure_context_dyn(${arg(0)})`);
+                case "tls.caCertsChk":
+                    // Always throws (validation error or the trailing fence).
+                    return finish(`(scr_tls_ca_certs_chk(${arg(0)}, ${arg(1)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 case "http.serverOnRequest": {
                     const cbT = e.args[1].type;
                     if (cbT.kind !== "func")
@@ -4067,6 +4189,15 @@ export function emitExpr(E, e) {
                     return finish(`scr_http2_stream_pending(${arg(0)})`);
                 case "http2.streamSession":
                     return finish(`scr_http2_stream_session(${arg(0)})`);
+                case "dyn.toStringCoerce":
+                    // +1 string or NULL with the exception pending (user
+                    // toString/valueOf throws propagate). Borrows the dyn.
+                    return finish(`scr_dyn_string_coerce_js(${arg(0)})`);
+                case "error.nodeThrow":
+                    // The compiler-resolved Node-parity throw (always throws —
+                    // the typed dummy is abandoned by the pending check's
+                    // unwind; releases are NULL-tolerant). Borrows both strings.
+                    return finish(`(scr_throw_node_coded(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 case "global.undefRead":
                     // A declare-d const nothing defines: Node's catchable
                     // ReferenceError at the access (always throws — the typed
@@ -4206,6 +4337,54 @@ export function emitExpr(E, e) {
                     return finish(`scr_bytes_byte_length_str(${arg(0)}, ${arg(1)})`);
                 case "buffer.isEncoding":
                     return finish(`scr_bytes_is_encoding(${arg(0)})`);
+                // The checked-dynamic compare/equals validators
+                // (scr_bytes_io.c): Node's argument ladders throw catchably
+                // (may-throw seed set); all dyn args borrowed.
+                case "buffer.compareChk":
+                    return finish(`scr_buffer_compare_chk(${arg(0)}, ${arg(1)})`);
+                case "bytes.equalsChk":
+                    return finish(`scr_bytes_equals_chk(${arg(0)}, ${arg(1)})`);
+                case "bytes.compareChk":
+                    return finish(`scr_bytes_compare_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
+                case "buffer.newStringFail":
+                    return finish(`scr_buffer_new_string_fail(${arg(0)})`);
+                case "fs.toUnixTimestamp":
+                    return finish(`scr_fs_to_unix_timestamp(${arg(0)})`);
+                // The fs argument-validation ladders: the always-throw Chk
+                // forms (validation error or the trailing fence) take the
+                // error.nodeThrow dummy pattern; mkdtempSyncChk and the lchmod
+                // pair answer real results on a validated pass.
+                case "fs.existsChk":
+                    E.usesTimers = true; // the scheduled answer holds the loop open
+                    return finish(`scr_fs_exists_async(${arg(0)}, ${arg(1)})`);
+                case "fs.mkdtempChk":
+                    return finish(`(scr_fs_mkdtemp_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.mkdtempSyncChk":
+                    return finish(`scr_fs_mkdtemp_sync_chk(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "fs.readFileChk":
+                    return finish(`(scr_fs_read_file_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.opendirChk":
+                    return finish(`(scr_fs_opendir_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.watchFileChk":
+                    return finish(`(scr_fs_watch_file_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.lchmodChk":
+                    return finish(`(scr_fs_lchmod_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.lchmodSyncChk":
+                    return finish(`scr_fs_lchmod_sync_chk(${arg(0)}, ${arg(1)})`);
+                case "fsp.lchmodChk":
+                    return finish(`scr_fsp_lchmod_chk(${arg(0)}, ${arg(1)})`);
+                case "fs.readChk":
+                    return finish(`(scr_fs_read_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.streamOptsChk":
+                    return finish(`(scr_fs_stream_opts_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "error.argTypeThrow":
+                    // Always throws with the runtime-rendered Received tail (the
+                    // error.nodeThrow dummy pattern). Borrows all three.
+                    return finish(`(scr_throw_arg_type(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "error.propTypeThrow":
+                    // The property flavor ("The \"options.x\" property must be
+                    // ...") — same always-throw dummy pattern.
+                    return finish(`(scr_throw_prop_type(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 // The fs Buffer forms (scr_bytes_io.c): the sync pair throws
                 // like the utf8 forms (may-throw seed set); the promise form
                 // rejects instead.
@@ -4630,6 +4809,27 @@ export function emitExpr(E, e) {
                     // Object.assign over DOM values: own members copy, the target
                     // returns (+1); non-object receivers throw like Node.
                     return finish(`scr_dyn_assign(${arg(0)}, ${arg(1)})`);
+                case "dyn.packPush":
+                    // Variadic Object.assign's source pack: a plain source
+                    // retains in (both args borrowed). Never throws.
+                    return finish(`scr_dyn_pack_push(${arg(0)}, ${arg(1)})`);
+                case "dyn.packPushSpread":
+                    // A spread source flattens through the spread-call walk —
+                    // V8's exact TypeError texts (may-throw seed set); the string
+                    // spells the spread expression for the nullish form.
+                    return finish(`scr_dyn_pack_push_spread(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "dyn.packPushSpreadIter":
+                    // The non-last/multi-spread positions: V8's iterator-protocol
+                    // failure texts describe the value (may-throw seed set).
+                    return finish(`scr_dyn_pack_push_spread_iter(${arg(0)}, ${arg(1)})`);
+                case "dyn.assignAll":
+                    // The flattened pack copies onto the target left to right;
+                    // the target returns (+1). Nullish targets throw like Node.
+                    return finish(`scr_dyn_assign_all(${arg(0)}, ${arg(1)})`);
+                case "dyn.objCreateNullProto":
+                    // Object.create(null): the fresh null-prototype dictionary
+                    // (+1). Never throws.
+                    return finish(`scr_dyn_new_obj_null_proto()`);
                 case "dyn.hasOwn":
                     // Object.hasOwn over a DOM receiver (throws on nullish, like
                     // Node's ToObject).
@@ -4756,10 +4956,15 @@ export function emitExpr(E, e) {
                     return finish(`scr_emitter_listeners((ScrEmitter *)${arg(0)}, ${arg(1)})`);
                 case "emitter.setMax":
                     return finish(`(${cType(e.type).trim()})scr_emitter_set_max((ScrEmitter *)${arg(0)}, ${arg(1)})`);
+                case "emitter.setMaxChk":
+                    // The checked-dynamic ladder (may throw); +1 receiver back.
+                    return finish(`(${cType(e.type).trim()})scr_emitter_set_max_chk((ScrEmitter *)${arg(0)}, ${arg(1)})`);
                 case "emitter.getMax":
                     return finish(`scr_emitter_get_max((ScrEmitter *)${arg(0)})`);
                 case "emitter.setDefaultMax":
                     return finish(`scr_emitter_set_default_max(${arg(0)})`);
+                case "emitter.setDefaultMaxChk":
+                    return finish(`scr_emitter_set_default_max_chk(${arg(0)}, ${arg(1)})`);
                 case "emitter.getDefaultMax":
                     return finish(`scr_emitter_get_default_max()`);
                 // node:stream (scr_stream.c — linked exactly when these appear,
@@ -4876,6 +5081,22 @@ export function emitExpr(E, e) {
                     const thunk = E.streamCbThunkFor("e", e.args[1 + n].type);
                     return finish(`(${cType(e.type).trim()})scr_stream_pipeline(${n}, (ScrStream *[]){ ${list} }, ${cb.name}, &${thunk})`);
                 }
+                case "sp.finished":
+                    // The stream/promises form: a +1 pending promise the terminal
+                    // watcher settles — no callback, no cleanup exposure.
+                    E.usesTimers = true;
+                    return finish(`scr_sp_finished((ScrStream *)${arg(0)})`);
+                case "sp.pipeline": {
+                    // pipeline(count, s1..sn) settling a void promise; the stream
+                    // list rides the callback form's compound literal.
+                    E.usesTimers = true;
+                    const countArg = e.args[0];
+                    if (countArg.kind !== "numLit")
+                        throw new Error(`emitter bug: ${fn} count not a literal`);
+                    const n = countArg.value;
+                    const list = Array.from({ length: n }, (_, i) => `(ScrStream *)${arg(1 + i)}`).join(", ");
+                    return finish(`scr_sp_pipeline(${n}, (ScrStream *[]){ ${list} })`);
+                }
                 case "readable.newDyn":
                 case "writable.newDyn":
                 case "duplex.newDyn":
@@ -5935,6 +6156,12 @@ export function emitExpr(E, e) {
                     const pack = argPack(args.slice(1).map((x) => x.name));
                     return finishFallible(`scr_jsval_call(${a(0)}, ${args.length - 1}, ${pack})`);
                 }
+                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).
+                    return finishFallible(`scr_jsval_call_spread(${a(0)}, ${a(1)}, ${a(2)}, ${nameSym()})`);
                 case "construct": {
                     // `new X(...)` on an island callee: JS_CallConstructor.
                     const pack = argPack(args.slice(1).map((x) => x.name));