@scriptc/compiler 0.0.9 → 0.0.11

package/ambient/scriptc-node-fallback.d.ts

@@ -447,7 +447,10 @@ interface Buffer<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends
 }
 interface BufferConstructor {
   from(data: string, encoding?: BufferEncoding): Buffer;
-  from(data: Uint8Array | ArrayBuffer | readonly number[]): Buffer;
+  /* The ArrayBuffer form is the VIEW construction: x.buffer with an
+   * optional byte offset/length shares x's storage (the subarray rule). */
+  from(data: ArrayBuffer, byteOffset?: number, length?: number): Buffer;
+  from(data: Uint8Array | readonly number[]): Buffer;
   alloc(size: number, fill?: string | number | Uint8Array, encoding?: BufferEncoding): Buffer;
   compare(buf1: Uint8Array, buf2: Uint8Array): number;
   /* alloc without the zero-fill guarantee — the lowering zero-fills
@@ -798,16 +801,38 @@ declare module "perf_hooks" {
  * performance.now() either way. */
 declare var performance: import("node:perf_hooks").Performance;
 
-/* node:module — the ADMIT-THEN-FENCE surface: the import compiles (the
- * module carries no evaluation), and every member keeps a per-site fence.
- * createRequire loads CommonJS from disk at runtime — a compiled
- * program's modules are fixed at build time, so the call's fence defers
- * to a runtime error in JS sources (the config-loader idiom is
- * reached only when a CJS config/plugin must load). Bare "module" stays a
- * package specifier (an npm package by that name exists); only the node:
- * spelling names the builtin. */
+/* node:module. createRequire's lowered shape is the version/config-
+ * reading pattern real CLIs ship: a const binding over
+ * createRequire(import.meta.url) (or __filename) whose require calls
+ * take STATIC string literals — the indirection erases at compile time.
+ * A builtin spec makes the binding a namespace import in const clothing;
+ * a relative .json document bakes and parses (JSON.parse's `unknown`
+ * stance — validate with a checked cast); an installed npm package loads
+ * through the island's require-condition entry under --dynamic; a bare
+ * name nothing installed resolves compiles to Node's catchable
+ * MODULE_NOT_FOUND throw (the optional-dependency try/require pattern).
+ * Dynamic specifiers fence: a compiled binary's module graph is fixed at
+ * build time. builtinModules is the baked Node v24 list (a fresh
+ * mutable array per read where Node ships one frozen singleton);
+ * isBuiltin and syncBuiltinESMExports fence per site. Bare "module"
+ * stays a package specifier (an npm package by that name exists); only
+ * the node: spelling names the builtin. */
 declare module "node:module" {
   export function createRequire(filename: string | URL): (id: string) => unknown;
+  export const builtinModules: string[];
+  export function isBuiltin(moduleName: string): boolean;
+  export function syncBuiltinESMExports(): void;
+}
+/* import.meta: module-loader metadata with no value representation —
+ * every read fences (SC1090) EXCEPT as createRequire's base, where it
+ * only NAMES the containing file (import.meta.url, import.meta.filename,
+ * and __filename all mean "this file" there). Declared so the pattern
+ * typechecks under the fallback surface; @types/node's own augmentation
+ * stands in when adopted. */
+interface ImportMeta {
+  url: string;
+  filename: string;
+  dirname: string;
 }
 
 /* The synchronous node:fs surface — utf8-only, no options objects, no
@@ -3148,3 +3173,23 @@ declare module "node:stream/promises" {
   import streamPromises = require("stream/promises");
   export = streamPromises;
 }
+declare module "stream/consumers" {
+  /* The promise consumers over a readable: accumulate every chunk and
+   * settle — text (the utf8 decode), json (the text through JSON.parse:
+   * `unknown`, validated with a checked cast; malformed input rejects
+   * with the parse's SyntaxError), buffer (the concatenated bytes;
+   * string chunks contribute their utf8 bytes, Node's Blob rule).
+   * Stream errors reject; an early close rejects with
+   * ERR_STREAM_PREMATURE_CLOSE. arrayBuffer and blob fence per site:
+   * neither value has a representation in a compiled binary. */
+  function text(stream: unknown): Promise<string>;
+  function json(stream: unknown): Promise<unknown>;
+  function buffer(stream: unknown): Promise<Buffer>;
+  function arrayBuffer(stream: unknown): Promise<ArrayBuffer>;
+  function blob(stream: unknown): Promise<unknown>;
+  export { arrayBuffer, blob, buffer, json, text };
+}
+declare module "node:stream/consumers" {
+  import streamConsumers = require("stream/consumers");
+  export = streamConsumers;
+}

package/dist/backend/emission/emit-exprs.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);
@@ -986,6 +1008,10 @@ export function emitExpr(E, e) {
                     // Omitted relative indices default like string slice: start 0,
                     // end +Infinity (math.h is always included). Fresh copy, +1.
                     return E.newTemp(e.type, `scr_bytes_slice(${r.name}, ${args[0]?.name ?? "0"}, ${args[1]?.name ?? "INFINITY"})`);
+                case "subarray":
+                    // Same defaults; the result is a +1 VIEW aliasing the
+                    // receiver's storage (subarray / Buffer's slice).
+                    return E.newTemp(e.type, `scr_bytes_subarray(${r.name}, ${args[0]?.name ?? "0"}, ${args[1]?.name ?? "INFINITY"})`);
                 case "setFrom": {
                     // dst.set(src, offset?) — void; throws Node's RangeError on
                     // overflow (may-throw seed).
@@ -1041,6 +1067,10 @@ export function emitExpr(E, e) {
                     E.emitPendingCheck();
                     return t;
                 }
+                case "fillElem":
+                    // Per-element TypedArray fill (non-u8): slice-style index
+                    // defaults, never throws; the receiver comes back +1.
+                    return E.newTemp(e.type, `scr_bytes_fill_elem(${r.name}, ${args[0].name}, ${args[1]?.name ?? "0"}, ${args[2]?.name ?? "INFINITY"})`);
                 case "fillStr": {
                     const n = e.args.length - 2;
                     const t = E.newTemp(e.type, `scr_bytes_fill_str(${r.name}, ${args[0].name}, ${args[1].name}, ${n}, ` +
@@ -1589,6 +1619,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
@@ -1867,6 +1904,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);
@@ -1876,8 +1916,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.
@@ -1899,26 +1939,40 @@ 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": {
@@ -2188,13 +2242,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.
@@ -2424,10 +2485,14 @@ export function emitExpr(E, e) {
                     return finish(`scr_math_max_arr(${arg(0)})`);
                 case "math.minArr":
                     return finish(`scr_math_min_arr(${arg(0)})`);
-                // Math.floor — C floor() IS the JS operation (math.h is always
-                // included). Borrows nothing; no throw.
+                // Math.floor/trunc/ceil — the C functions ARE the JS operations
+                // (math.h is always included). Borrow nothing; no throw.
                 case "math.floor":
                     return finish(`floor(${arg(0)})`);
+                case "math.trunc":
+                    return finish(`trunc(${arg(0)})`);
+                case "math.ceil":
+                    return finish(`ceil(${arg(0)})`);
                 // Math.abs — C fabs IS the JS operation. Math.round — the JS
                 // half-toward-+Infinity rule (scr_lib.c; C round() differs on
                 // halves and naive floor(x+0.5) drifts at the epsilon boundary).
@@ -3041,6 +3106,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];
@@ -3143,6 +3217,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
@@ -3850,6 +3927,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")
@@ -4278,10 +4362,41 @@ export function emitExpr(E, e) {
                     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.
@@ -4706,6 +4821,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).
@@ -4973,6 +5109,18 @@ export function emitExpr(E, e) {
                     const list = Array.from({ length: n }, (_, i) => `(ScrStream *)${arg(1 + i)}`).join(", ");
                     return finish(`scr_sp_pipeline(${n}, (ScrStream *[]){ ${list} })`);
                 }
+                case "sc.text":
+                    // stream/consumers: +1 pending promises the accumulate-and-
+                    // settle machinery resolves or rejects (the stream's
+                    // error / premature close / json's SyntaxError).
+                    E.usesTimers = true;
+                    return finish(`scr_sc_text((ScrStream *)${arg(0)})`);
+                case "sc.json":
+                    E.usesTimers = true;
+                    return finish(`scr_sc_json((ScrStream *)${arg(0)})`);
+                case "sc.buffer":
+                    E.usesTimers = true;
+                    return finish(`scr_sc_buffer((ScrStream *)${arg(0)})`);
                 case "readable.newDyn":
                 case "writable.newDyn":
                 case "duplex.newDyn":
@@ -5028,6 +5176,14 @@ export function emitExpr(E, e) {
                 case "readable.pushStr":
                     E.usesTimers = true;
                     return finish(`scr_stream_push_str((ScrStream *)${arg(0)}, ${arg(1)})`);
+                case "readable.pushStrEnc":
+                    // push(chunk, enc) with a literal non-utf8 encoding.
+                    E.usesTimers = true;
+                    return finish(`scr_stream_push_str_enc((ScrStream *)${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "readable.pushEncoding":
+                    // The defaultEncoding option's push side (chaining, +1).
+                    E.usesTimers = true;
+                    return finish(`(${cType(e.type).trim()})scr_stream_set_push_encoding((ScrStream *)${arg(0)}, ${arg(1)})`);
                 case "readable.pushNull":
                     E.usesTimers = true;
                     return finish(`scr_stream_push_null((ScrStream *)${arg(0)})`);