@scriptc/compiler 0.1.3 → 0.1.5

package/dist/backend/c/exprs.js

@@ -1,12 +1,12 @@
 import { InternalCompilerError } from "../../errors.js";
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, CHILDWRITER_T, DYN, F64, islandPromisePayloadTag, isClassOwnEnumerableFieldName, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, CHILDWRITER_T, DYN, F64, islandPromisePayloadTag, isClassOwnEnumerableFieldName, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, NETSOCKET_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.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, releaseCallC, retainCallC, vAdapters } from "./types.js";
 import { mangleClassNew, mangleClassRetain, mangleClassStruct, mangleField, mangleFnClosure, mangleFunction, mangleGlobal, mangleLocal, mangleRecordClone, mangleRecordNew, mangleRecordStruct, mangleVtStruct } from "../mangle.js";
 import { OVERFLOW_MEMBER } from "./shapes.js";
 import { dynDestrCheckHelper, dynIterNHelper, dynKeyGetHelper } from "./walkers.js";
 import { collectFfiRetainedOps, parseFfiCallbackKey } from "../ffi-callbacks.js";
 import { genResultThunkFor } from "./async.js";
-import { isStableBytesOperand, matchStringSelfConcat, newValueMayThrow, streamTypedRefEligible, undefinedArmTag } from "../../ir/analysis.js";
+import { isStableReceiverOperand, matchStringSelfConcat, newValueMayThrow, streamTypedRefEligible, undefinedArmTag } from "../../ir/analysis.js";
 function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
     if (t.kind === "bytes") {
         const commit = `${snapshot}_commit`;
@@ -385,13 +385,13 @@ function dynPromiseAdapter(emitter, inner) {
     emitter.walkerDefs.push(`${sig} { /* checked-dynamic promise exit ${key} */`, `  ScrDyn *sc_d = (ScrDyn *)scr_promise_payload_ref(sc_src);`, `  ${cDecl(inner, "sc_v")} = ${emitter.dynCheckHelper(inner)}(sc_d, NULL);`, `  scr_dyn_release(sc_d);`, `  if (scr_exc_pending()) {`, `    scr_promise_reject_pending(sc_dst);`, `    return;`, `  }`, `  ${fulfill}`, `}`, ``);
     return sym;
 }
-/** Evaluate a bytes receiver as a borrow when it is a direct, unboxed
+/** Evaluate a receiver as a borrow when it is a direct, unboxed
  * binding and all later operands are stable. The binding's scope/global
  * owner then keeps the value alive, avoiding retain/release traffic around
  * every indexed access. Any uncertain shape falls back to an owned temp. */
-export function emitBytesReceiver(emitter, receiver, following) {
+export function emitStableReceiver(emitter, receiver, following) {
     if (receiver.kind === "varRef" &&
-        following.every((operand) => isStableBytesOperand(operand, receiver.localId))) {
+        following.every((operand) => isStableReceiverOperand(operand, receiver.localId))) {
         const local = emitter.currentLocals.get(receiver.localId);
         if (local && !local.boxed) {
             return emitter.newBorrowedTemp(receiver.type, mangleLocal(receiver.localId));
@@ -547,6 +547,10 @@ function emitLiteralExpr(emitter, e) {
             const sym = emitter.internLiteral(e.value);
             return emitter.newTemp(e.type, retainCallC(e.type, `(ScrStr *)&${sym}`));
         }
+        case "moduleNsRef": {
+            const sym = emitter.internLiteral(`module:${e.moduleId}`);
+            return emitter.newTemp(e.type, retainCallC(e.type, `(ScrStr *)&${sym}`));
+        }
         case "unitLit":
             // unitLits are consumed inline by the unionWrap case (a unit arm is
             // tag-only); one reaching the generic dispatch escaped its wrap.
@@ -600,11 +604,36 @@ function emitLiteralExpr(emitter, e) {
         }
     }
 }
+/** Unsigned operations avoid signed overflow and implementation-defined
+ * right shifts/conversions. Reinterpret the final bits numerically. */
+function emitIntegerBits(emitter, e, left, right) {
+    const a = `sc_bits_${emitter.tempCounter++}`;
+    const out = `sc_bits_${emitter.tempCounter++}`;
+    emitter.line(`uint32_t ${a} = (uint32_t)(int64_t)${left};`);
+    let operation;
+    if (e.kind === "unary")
+        operation = `~${a}`;
+    else {
+        const b = `sc_bits_${emitter.tempCounter++}`;
+        const shift = e.op === "<<" || e.op === ">>" || e.op === ">>>";
+        emitter.line(`uint32_t ${b} = (uint32_t)(int64_t)${right}${shift ? " & 31u" : ""};`);
+        operation = e.op === ">>" ? `(${a} >> ${b}) | ((${a} & 0x80000000u) ? ~(UINT32_MAX >> ${b}) : 0u)`
+            : `${a} ${e.op === ">>>" ? ">>" : e.op} ${b}`;
+    }
+    emitter.line(`uint32_t ${out} = ${operation};`);
+    return emitter.newTemp(e.type, e.op === ">>>" ? `(double)${out}` : `(double)${out} - ((${out} & 0x80000000u) ? 4294967296.0 : 0.0)`);
+}
 function emitOperatorExpr(emitter, e) {
     switch (e.kind) {
         case "bin": {
             const l = emitter.emitExpr(e.left);
             const r = emitter.emitExpr(e.right);
+            if ((e.op === "+" || e.op === "-") && emitter.integerRanges.get(e)) {
+                return emitter.newTemp(e.type, `(double)((int64_t)${l.name} ${e.op} (int64_t)${r.name})`);
+            }
+            if (["&", "|", "^", "<<", ">>", ">>>"].includes(e.op) && emitter.integerRanges.get(e.left) && emitter.integerRanges.get(e.right)) {
+                return emitIntegerBits(emitter, e, l.name, r.name);
+            }
             switch (e.op) {
                 case "%":
                     return emitter.newTemp(e.type, `fmod(${l.name}, ${r.name})`);
@@ -635,7 +664,8 @@ function emitOperatorExpr(emitter, e) {
         case "unary": {
             const v = emitter.emitExpr(e.operand);
             if (e.op === "~")
-                return emitter.newTemp(e.type, `scr_bit_not(${v.name})`);
+                return emitter.integerRanges.get(e.operand)
+                    ? emitIntegerBits(emitter, e, v.name) : emitter.newTemp(e.type, `scr_bit_not(${v.name})`);
             return emitter.newTemp(e.type, `${e.op}${v.name}`);
         }
         case "incDec": {
@@ -1229,9 +1259,13 @@ function emitStringExpr(emitter, e) {
                     }
                     return emitter.newTemp(e.type, `scr_str_includes(${r.name}, ${args[0].name})`);
                 case "startsWith":
-                    return emitter.newTemp(e.type, `scr_str_starts_with(${r.name}, ${args[0].name})`);
+                    return emitter.newTemp(e.type, args[1]
+                        ? `scr_str_starts_with_from(${r.name}, ${args[0].name}, ${args[1].name})`
+                        : `scr_str_starts_with(${r.name}, ${args[0].name})`);
                 case "endsWith":
-                    return emitter.newTemp(e.type, `scr_str_ends_with(${r.name}, ${args[0].name})`);
+                    return emitter.newTemp(e.type, args[1]
+                        ? `scr_str_ends_with_from(${r.name}, ${args[0].name}, ${args[1].name})`
+                        : `scr_str_ends_with(${r.name}, ${args[0].name})`);
                 case "slice":
                     return emitter.newTemp(e.type, `scr_str_slice(${r.name}, ${args[0]?.name ?? "0"}, ${args[1]?.name ?? "INFINITY"})`);
                 case "substring":
@@ -1443,7 +1477,11 @@ function emitContainerExpr(emitter, e) {
             return emitter.newTemp(e.type, `scr_arr_state(${arr.name}, ${idx.name})`);
         }
         case "arrIntrinsic": {
-            const r = emitter.emitExpr(e.receiver);
+            // getNumber copies out a scalar without invoking user code. A
+            // stable binding can own its receiver until that lookup finishes.
+            const r = e.method === "getNumber"
+                ? emitStableReceiver(emitter, e.receiver, e.args)
+                : emitter.emitExpr(e.receiver);
             if (e.receiver.type.kind !== "array")
                 throw new InternalCompilerError("emitter bug: arrIntrinsic on non-array");
             const acc = elemAccess(e.receiver.type.elem);
@@ -1451,6 +1489,11 @@ function emitContainerExpr(emitter, e) {
             switch (method) {
                 case "length":
                     return emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
+                case "getNumber": {
+                    const index = emitter.emitExpr(e.args[0]);
+                    const table = e.receiver.kind === "varRef" ? emitter.constantNumericTables.get(e.receiver.localId) : undefined;
+                    return emitter.newTemp(e.type, `${table ? `${table.symbol}_get` : "scr_arr_get_number"}(${r.name}, ${index.name})`);
+                }
                 case "nextPresent": {
                     const start = emitter.emitExpr(e.args[0]);
                     return emitter.newTemp(e.type, `scr_arr_next_present(${r.name}, ${start.name})`);
@@ -1673,7 +1716,7 @@ function emitContainerExpr(emitter, e) {
             const method = e.method;
             const directElementAccess = method === "length" || method === "byteLength" || method === "get";
             const r = directElementAccess
-                ? emitBytesReceiver(emitter, e.receiver, e.args)
+                ? emitStableReceiver(emitter, e.receiver, e.args)
                 : emitter.emitExpr(e.receiver);
             const integerIndex = method === "get" ? emitter.integerLoopIndex(e.args[0]) : null;
             const args = integerIndex === null ? e.args.map((a) => emitter.emitExpr(a)) : [];
@@ -1684,7 +1727,7 @@ function emitContainerExpr(emitter, e) {
                     if (e.receiver.type.kind !== "bytes") {
                         throw new InternalCompilerError("emitter bug: bytesIntrinsic byteLength on non-bytes");
                     }
-                    return emitter.newTemp(e.type, `(double)(${r.name}->len * ${e.receiver.type.elem === "u8" ? "1" : "4"})`);
+                    return emitter.newTemp(e.type, `(double)(${r.name}->len * ${e.receiver.type.elem === "u8" ? "1" : e.receiver.type.elem === "f64" ? "8" : "4"})`);
                 case "get":
                     // Any invalid index traps (the array runtime's discipline).
                     if (e.receiver.type.kind !== "bytes") {
@@ -4016,6 +4059,11 @@ function emitDynamicLibCall(state) {
             // +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 "dyn.toNumberCoerce":
+            // JS ToNumber (number-hint valueOf/toString protocol). A
+            // thrown hook leaves the exception pending; the may-throw
+            // epilogue abandons the NaN dummy.
+            return finish(`scr_dyn_number_coerce(${arg(0)})`);
         case "global.undefRead":
             // A declare-d const nothing defines: Node's catchable
             // ReferenceError at the access (always throws — the typed
@@ -4103,22 +4151,28 @@ function emitFilesystemLibCall(state) {
             return finish(`scr_fs_rmdir(${arg(0)})`);
         case "fs.readdirSync":
             return finish(`scr_fs_readdir(${arg(0)})`);
-        case "fs.readdirTypesSync": {
+        case "fs.readdirTypesSync":
+        case "fsp.readdirTypes": {
             // Dirent rows assembled inline from one scandir snapshot
             // (scr_lib.c) — the os.networkInterfaces pattern, flat. The
             // frontend/validator pinned the shape ({%dtype, name,
-            // parentPath}); lookups here only guard emitter bugs. The
-            // snapshot call throws Node's scandir error (may-throw seed
-            // set) and answers NULL then, so the pending check runs
-            // before any allocation.
-            if (e.type.kind !== "array" || e.type.elem.kind !== "record") {
-                throw new InternalCompilerError("emitter bug: readdirTypesSync result is not a record array");
-            }
-            const recT = e.type.elem;
+            // parentPath}); lookups here only guard emitter bugs. The sync
+            // form checks the snapshot's scandir error immediately. The
+            // promise form lets NULL flow through the null-tolerant count/
+            // free accessors, builds an empty dummy array, and moves it to
+            // settled_ref: the pending exception becomes the rejection and
+            // settled_ref releases that dummy.
+            const promiseForm = e.fn === "fsp.readdirTypes";
+            const arrayT = promiseForm && e.type.kind === "promise" ? e.type.inner : e.type;
+            if (arrayT.kind !== "array" || arrayT.elem.kind !== "record") {
+                throw new InternalCompilerError(`emitter bug: ${e.fn} result is not a Dirent record array`);
+            }
+            const recT = arrayT.elem;
             const snap = `sc_t${emitter.tempCounter++}`;
             emitter.line(`ScrScandir *${snap} = scr_fs_scandir(${arg(0)});${emitter.srcComment(e.loc)}`);
-            emitter.emitPendingCheck();
-            const out = emitter.newTemp(e.type, emitter.arrNewC(recT, `scr_fs_scandir_count(${snap})`));
+            if (!promiseForm)
+                emitter.emitPendingCheck();
+            const out = emitter.newTemp(arrayT, emitter.arrNewC(recT, `scr_fs_scandir_count(${snap})`));
             const i = `sc_t${emitter.tempCounter++}`;
             const n = `sc_t${emitter.tempCounter++}`;
             emitter.line(`for (size_t ${i} = 0, ${n} = scr_fs_scandir_count(${snap}); ${i} < ${n}; ${i}++) {`);
@@ -4132,6 +4186,11 @@ function emitFilesystemLibCall(state) {
             emitter.indent--;
             emitter.line(`}`);
             emitter.line(`scr_fs_scandir_free(${snap});`);
+            if (promiseForm) {
+                const rc = vAdapters(arrayT);
+                emitter.moveTemp(out); // promise fulfillment owns the result array
+                return finish(`scr_promise_settled_ref(${out.name}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(arrayT)})`);
+            }
             return out;
         }
         // Stats (scr_lib.c): statSync throws like the other sync fs
@@ -4140,6 +4199,16 @@ function emitFilesystemLibCall(state) {
             // Throws Node-shaped fs errors (may-throw seed set); the fd
             // comes back as f64.
             return finish(`scr_fs_open(${arg(0)}, ${arg(1)})`);
+        case "fs.openNumericSync":
+            return finish(`scr_fs_open_numeric(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+        case "fs.fstatSync":
+            return finish(`scr_fs_fstat(${arg(0)})`);
+        case "fs.fchmodSync":
+            return finish(`scr_fs_fchmod(${arg(0)}, ${arg(1)})`);
+        case "fs.fsyncSync":
+            return finish(`scr_fs_fsync(${arg(0)})`);
+        case "fs.linkSync":
+            return finish(`scr_fs_link(${arg(0)}, ${arg(1)})`);
         case "fs.readSync":
             return finish(`scr_fs_read_sync(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)})`);
         case "fs.writeSync":
@@ -4182,12 +4251,18 @@ function emitFilesystemLibCall(state) {
             return finish(`scr_stats_atime_ms(${arg(0)})`);
         case "stats.mtimeMs":
             return finish(`scr_stats_mtime_ms(${arg(0)})`);
+        case "stats.ctimeMs":
+            return finish(`scr_stats_ctime_ms(${arg(0)})`);
         case "stats.isFile":
             return finish(`scr_stats_is_file(${arg(0)})`);
         case "stats.isDirectory":
             return finish(`scr_stats_is_dir(${arg(0)})`);
         case "stats.size":
             return finish(`scr_stats_size(${arg(0)})`);
+        case "stats.dev":
+            return finish(`scr_stats_dev(${arg(0)})`);
+        case "stats.ino":
+            return finish(`scr_stats_ino(${arg(0)})`);
         case "fs.toUnixTimestamp":
             return finish(`scr_fs_to_unix_timestamp(${arg(0)})`);
         // The fs argument-validation ladders: the always-throw Chk
@@ -4246,6 +4321,43 @@ function emitFilesystemLibCall(state) {
             return finish(`scr_zlib_deflate(${arg(0)})`);
         case "zlib.inflateSync":
             return finish(`scr_zlib_inflate(${arg(0)})`);
+        case "zlib.deflateRawSync":
+            return finish(`scr_zlib_deflate_mode(${arg(0)}, 1.0, -1.0)`);
+        case "zlib.inflateRawSync":
+            return finish(`scr_zlib_inflate_mode(${arg(0)}, 1.0)`);
+        case "zlib.gzipSync":
+            return finish(`scr_zlib_deflate_mode(${arg(0)}, 2.0, -1.0)`);
+        case "zlib.gunzipSync":
+            return finish(`scr_zlib_inflate_mode(${arg(0)}, 2.0)`);
+        case "zlib.unzipSync":
+            return finish(`scr_zlib_inflate_mode(${arg(0)}, 3.0)`);
+        case "zlib.crc32":
+            return finish(`scr_zlib_crc32(${arg(0)}, ${arg(1)})`);
+        case "zlib.deflateCb":
+        case "zlib.inflateCb":
+        case "zlib.deflateRawCb":
+        case "zlib.inflateRawCb":
+        case "zlib.gzipCb":
+        case "zlib.gunzipCb":
+        case "zlib.unzipCb": {
+            emitter.usesTimers = true;
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: zlib callback not a func");
+            const callback = args[1];
+            emitter.moveTemp(callback);
+            const adapter = emitter.zlibBytesThunkFor(cbT);
+            const compressing = fn === "zlib.deflateCb" || fn === "zlib.deflateRawCb" || fn === "zlib.gzipCb";
+            const mode = fn === "zlib.deflateRawCb" || fn === "zlib.inflateRawCb"
+                ? 1
+                : fn === "zlib.gzipCb" || fn === "zlib.gunzipCb"
+                    ? 2
+                    : fn === "zlib.unzipCb"
+                        ? 3
+                        : 0;
+            emitter.line(`scr_zlib_codec_async(${arg(0)}, ${mode}.0, ${compressing ? "true" : "false"}, ${callback.name}, &${adapter});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "fsp.readFile":
             return finish(`scr_fsp_read_file(${arg(0)})`);
         case "fsp.writeFile":
@@ -4272,6 +4384,10 @@ function emitFilesystemLibCall(state) {
             return finish(`scr_fsp_rm(${arg(0)})`);
         case "fsp.stat":
             return finish(`scr_fsp_stat(${arg(0)})`);
+        case "fsp.realpath":
+            return finish(`scr_fsp_realpath(${arg(0)})`);
+        case "fsp.lstat":
+            return finish(`scr_fsp_lstat(${arg(0)})`);
         case "fsp.open":
             return finish(`scr_fsp_open(${arg(0)}, ${arg(1)}, ${arg(2)})`);
         case "fileHandle.fd":
@@ -4535,10 +4651,18 @@ function emitPathUrlLibCall(state) {
             return finish(`scr_url_new(${arg(0)})`);
         case "url.protocol":
             return finish(`scr_url_protocol(${arg(0)})`);
+        case "url.origin":
+            return finish(`scr_url_origin(${arg(0)})`);
+        case "url.username":
+            return finish(`scr_url_username(${arg(0)})`);
+        case "url.password":
+            return finish(`scr_url_password(${arg(0)})`);
         case "url.host":
             return finish(`scr_url_host(${arg(0)})`);
         case "url.hostname":
             return finish(`scr_url_hostname(${arg(0)})`);
+        case "url.port":
+            return finish(`scr_url_port(${arg(0)})`);
         case "url.pathname":
             return finish(`scr_url_pathname(${arg(0)})`);
         case "url.href":
@@ -4572,6 +4696,8 @@ function emitPathUrlLibCall(state) {
             return finish(`scr_url_search_params(${arg(0)})`);
         case "url.search":
             return finish(`scr_url_search(${arg(0)})`);
+        case "url.hash":
+            return finish(`scr_url_hash(${arg(0)})`);
         case "sp.get": {
             // `string | null` — the sym.desc pattern with a null arm: the
             // runtime answers a +1 string or NULL.
@@ -4677,6 +4803,8 @@ function emitPrimitiveLibCall(state) {
             return finish(`scr_math_max_arr(${arg(0)})`);
         case "math.minArr":
             return finish(`scr_math_min_arr(${arg(0)})`);
+        case "math.hypotArr":
+            return finish(`scr_math_hypot_arr(${arg(0)})`);
         // Math.floor/trunc/ceil — the C functions ARE the JS operations
         // (math.h is always included). Borrow nothing; no throw.
         case "math.floor":
@@ -4685,6 +4813,38 @@ function emitPrimitiveLibCall(state) {
             return finish(`trunc(${arg(0)})`);
         case "math.ceil":
             return finish(`ceil(${arg(0)})`);
+        case "math.sin":
+            return finish(`sin(${arg(0)})`);
+        case "math.cos":
+            return finish(`cos(${arg(0)})`);
+        case "math.tan":
+            return finish(`tan(${arg(0)})`);
+        case "math.asin":
+            return finish(`asin(${arg(0)})`);
+        case "math.acos":
+            return finish(`acos(${arg(0)})`);
+        case "math.atan":
+            return finish(`atan(${arg(0)})`);
+        case "math.cbrt":
+            return finish(`cbrt(${arg(0)})`);
+        case "math.sign":
+            // Each argument was evaluated into a temp. Returning that temp
+            // for unordered/zero inputs preserves NaN and the sign of zero.
+            return finish(`(${arg(0)} > 0.0 ? 1.0 : (${arg(0)} < 0.0 ? -1.0 : ${arg(0)}))`);
+        case "math.exp":
+            return finish(`exp(${arg(0)})`);
+        case "math.sqrt":
+            return finish(`sqrt(${arg(0)})`);
+        case "math.log":
+            return finish(`log(${arg(0)})`);
+        case "math.log2":
+            return finish(`log2(${arg(0)})`);
+        case "math.log10":
+            return finish(`log10(${arg(0)})`);
+        case "math.atan2":
+            return finish(`atan2(${arg(0)}, ${arg(1)})`);
+        case "math.pow":
+            return finish(`scr_math_pow(${arg(0)}, ${arg(1)})`);
         // 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).
@@ -4796,6 +4956,8 @@ function emitPrimitiveLibCall(state) {
             return finish(`scr_bigint_shr(${arg(0)}, ${arg(1)})`);
         case "bigint.eq":
             return finish(`scr_bigint_eq(${arg(0)}, ${arg(1)})`);
+        case "bigint.eqString":
+            return finish(`scr_bigint_eq_string(${arg(0)}, ${arg(1)})`);
         case "bigint.cmp":
             return finish(`scr_bigint_cmp_f64(${arg(0)}, ${arg(1)})`);
         case "bigint.cmpNumber":
@@ -4868,6 +5030,7 @@ function emitPrimitiveLibCall(state) {
             // +1 string, or Node's "Invalid time value" RangeError
             // (may-throw seed set).
             return finish(`scr_date_to_iso(${arg(0)})`);
+        case "date.parse":
         case "date.parseGetTime":
             // The bounded date-string parse (X509 validity + ECMA format);
             // NaN elsewhere. Never throws.
@@ -4925,6 +5088,8 @@ function emitPrimitiveLibCall(state) {
                 : `scr_str_from_char_code(${arg(0)})`);
         case "string.lastIndexOf":
             return finish(`scr_str_last_index_of(${arg(0)}, ${arg(1)})`);
+        case "string.lastIndexOfFrom":
+            return finish(`scr_str_last_index_of_from(${arg(0)}, ${arg(1)}, ${arg(2)})`);
         case "string.raw":
             // Raw literals + pre-stringified substitutions; +1 string.
             return finish(`scr_str_raw(${arg(0)}, ${arg(1)})`);
@@ -5244,20 +5409,37 @@ function emitChildProcessLibCall(state) {
         case "cp.spawn":
             emitter.usesTimers = true; // the loop must run to reap the child
             return finish(`scr_spawn(${arg(0)}, ${arg(1)})`);
+        case "cp.fork":
+            emitter.usesTimers = true;
+            return finish(`scr_fork(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)}, ${arg(7)})`);
         case "cp.spawnOpts":
             // The options form: per-slot stdio (ignore/inherit/fd — the
             // fds dup2 into the child), detached (setsid), env
             // replacement, cwd. Same loop/reap story as cp.spawn.
             emitter.usesTimers = true;
-            return finish(`scr_spawn_opts(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)}, ${arg(7)}, ${arg(8)}, ${arg(9)}, ${arg(10)})`);
-        case "child.onExit": {
+            return finish(`scr_spawn_opts(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)}, ${arg(7)}, ${arg(8)}, ${arg(9)}, ${arg(10)}, ${arg(11)})`);
+        case "cp.execFile": {
+            const callbackArg = e.args[2];
+            const cb = args[2];
+            if (!callbackArg || !cb)
+                throw new InternalCompilerError("emitter bug: execFile callback missing");
+            const cbT = callbackArg.type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: execFile callback not a func");
+            emitter.moveTemp(cb);
+            const adapter = emitter.execFileThunkFor(cbT);
+            emitter.usesTimers = true;
+            return finish(`scr_exec_file(${arg(0)}, ${arg(1)}, ${cb.name}, &${adapter})`);
+        }
+        case "child.onExit":
+        case "child.onClose": {
             // The callback MOVES into the child's registry; the third
             // ingredient is the ADAPTER — emitted per callback shape,
             // because the `number | null` union's tags are program data
             // (a zero-param listener gets the runtime's ignoring thunk).
             const cbT = e.args[1].type;
             if (cbT.kind !== "func")
-                throw new InternalCompilerError("emitter bug: child.onExit callback not a func");
+                throw new InternalCompilerError(`emitter bug: ${e.fn} callback not a func`);
             const cb = args[1];
             emitter.moveTemp(cb);
             const adapter = cbT.params.length === 0
@@ -5265,7 +5447,7 @@ function emitChildProcessLibCall(state) {
                 : cbT.params.length === 1
                     ? emitter.childExitThunkFor(cbT.params[0])
                     : emitter.childExitSignalThunkFor(cbT.params[0], cbT.params[1]);
-            emitter.line(`scr_child_on_exit(${arg(0)}, ${cb.name}, &${adapter});${emitter.srcComment(e.loc)}`);
+            emitter.line(`${e.fn === "child.onClose" ? "scr_child_on_close" : "scr_child_on_exit"}(${arg(0)}, ${cb.name}, &${adapter});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
         case "child.onError": {
@@ -5280,6 +5462,43 @@ function emitChildProcessLibCall(state) {
             emitter.line(`scr_child_on_error(${arg(0)}, ${cb.name}, &${adapter});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
+        case "child.connected":
+            return finish(`scr_child_ipc_connected(${arg(0)})`);
+        case "child.send":
+            emitter.usesTimers = true;
+            return finish(`scr_child_ipc_send(${arg(0)}, ${arg(1)})`);
+        case "child.sendCb": {
+            const cbT = e.args[2].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: child.send callback not a func");
+            const cb = args[2];
+            emitter.moveTemp(cb);
+            emitter.usesTimers = true;
+            return finish(`scr_child_ipc_send_cb(${arg(0)}, ${arg(1)}, ${cb.name}, &${emitter.ipcSendThunkFor(cbT)})`);
+        }
+        case "child.disconnect":
+            emitter.usesTimers = true;
+            return finish(`scr_child_ipc_disconnect(${arg(0)})`);
+        case "child.onMessage": {
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: child message listener not a func");
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            emitter.usesTimers = true;
+            emitter.line(`scr_child_ipc_on_message(${arg(0)}, ${cb.name}, &${emitter.ipcMessageThunkFor(cbT)}, ${arg(2)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "child.onDisconnect": {
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: child disconnect listener not a func");
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            emitter.usesTimers = true;
+            emitter.line(`scr_child_ipc_on_disconnect(${arg(0)}, ${cb.name}, ${arg(2)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         default:
             throw new InternalCompilerError(`emitter bug: childProcess libCall dispatch for ${fn}`);
     }
@@ -5377,6 +5596,8 @@ function emitNetworkLibCall(state) {
         }
         case "net.serverPort":
             return finish(`scr_net_server_port(${arg(0)})`);
+        case "net.serverListening":
+            return finish(`scr_net_server_listening(${arg(0)})`);
         case "net.serverAddress": {
             // The AddressInfo record from the three runtime reads (the
             // dgram.address materialization; none of these throw).
@@ -5454,9 +5675,7 @@ function emitNetworkLibCall(state) {
             const cb = args[1];
             emitter.moveTemp(cb);
             const adapter = cbT.params.length === 0 ? "scr_net_conn_thunk0" : "scr_net_conn_thunk_sock";
-            const entry = e.fn === "net.serverOnConnection"
-                ? "scr_net_server_on_connection"
-                : "scr_net_server_on_secure_connection";
+            const entry = e.fn === "net.serverOnConnection" ? "scr_net_server_on_connection" : "scr_net_server_on_secure_connection";
             emitter.line(`${entry}(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
@@ -5857,7 +6076,8 @@ function emitHttpLibCall(state) {
             return finish(`scr_http_req_aborted_flag(${arg(0)})`);
         case "http.reqComplete":
             return finish(`scr_http_req_complete(${arg(0)})`);
-        case "http.reqHeader": {
+        case "http.reqHeader":
+        case "http.reqTrailer": {
             // string|undefined, type-directed exactly like process.envGet:
             // the runtime answers +1 or NULL; NULL takes the undefined arm.
             if (e.type.kind !== "union")
@@ -5868,12 +6088,29 @@ function emitHttpLibCall(state) {
             if (strTag < 0 || undefTag < 0) {
                 throw new InternalCompilerError("emitter bug: http.reqHeader union lacks its arms");
             }
-            const s = emitter.newTemp(STRING, `scr_http_req_header(${arg(0)}, ${arg(1)})`);
+            const entry = e.fn === "http.reqHeader" ? "scr_http_req_header" : "scr_http_req_trailer";
+            const s = emitter.newTemp(STRING, `${entry}(${arg(0)}, ${arg(1)})`);
             emitter.moveTemp(s); // moves into the box when present; NULL otherwise
             const present = `scr_union_new_ref(${strTag}, ${s.name}, &scr_str_retain_v, &scr_str_release_v, NULL)`;
             const absent = emitter.unitInstanceRef(e.type.unionId, undefTag);
             return emitter.newTemp(e.type, `${s.name} ? ${present} : ${absent}`);
         }
+        case "http.reqHeaderValues":
+        case "http.reqTrailerValues": {
+            if (e.type.kind !== "union")
+                throw new InternalCompilerError("emitter bug: distinct header result is not a union");
+            const def = emitter.unionsById.get(e.type.unionId);
+            const arrTag = def ? def.arms.findIndex((a) => a.kind === "array") : -1;
+            const undefTag = undefinedArmTag(e.type, emitter.unionsById);
+            if (arrTag < 0 || undefTag < 0)
+                throw new InternalCompilerError("emitter bug: distinct header union lacks its arms");
+            const entry = e.fn === "http.reqHeaderValues" ? "scr_http_req_header_values" : "scr_http_req_trailer_values";
+            const values = emitter.newTemp(arrayOf(STRING), `${entry}(${arg(0)}, ${arg(1)})`);
+            emitter.moveTemp(values);
+            const present = `scr_union_new_ref(${arrTag}, ${values.name}, &scr_arr_retain_v, &scr_arr_release_v, NULL)`;
+            const absent = emitter.unitInstanceRef(e.type.unionId, undefTag);
+            return emitter.newTemp(e.type, `${values.name} ? ${present} : ${absent}`);
+        }
         case "http.reqOnData": {
             const cbT = e.args[1].type;
             if (cbT.kind !== "func")
@@ -5896,35 +6133,51 @@ function emitHttpLibCall(state) {
         case "http.resSetHeader":
             emitter.line(`scr_http_res_set_header(${arg(0)}, ${arg(1)}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
-        case "http.resWriteHead":
-            emitter.line(`scr_http_res_write_head(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+        case "http.validateHeaderName":
+            emitter.line(`scr_http_validate_header_name(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
-        case "http.resWriteHeadN":
-            emitter.line(`scr_http_res_write_head_n(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)});${emitter.srcComment(e.loc)}`);
+        case "http.validateHeaderValue":
+            emitter.line(`scr_http_validate_header_value(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
+        case "http.resWriteHead":
+            return finish(`scr_http_res_write_head(${arg(0)}, ${arg(1)})`);
+        case "http.resWriteHeadN":
+            return finish(`scr_http_res_write_head_n(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+        case "http.resWriteContinue":
+            return finish(`scr_http_res_write_continue(${arg(0)})`);
+        case "http.resWriteProcessing":
+            return finish(`scr_http_res_write_processing(${arg(0)})`);
+        case "http.resWriteEarlyHints":
+            return finish(`scr_http_res_write_early_hints(${arg(0)}, ${arg(1)})`);
         case "http.resWrite":
-            emitter.line(`scr_http_res_write_str(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_write_str(${arg(0)}, ${arg(1)})`);
         case "http.resWriteBytes":
-            emitter.line(`scr_http_res_write_bytes(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_write_bytes(${arg(0)}, ${arg(1)})`);
         case "http.resEnd":
-            emitter.line(`scr_http_res_end(${arg(0)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_end(${arg(0)})`);
         case "http.resEndStr":
-            emitter.line(`scr_http_res_end_str(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_end_str(${arg(0)}, ${arg(1)})`);
         case "http.resEndBytes":
-            emitter.line(`scr_http_res_end_bytes(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_end_bytes(${arg(0)}, ${arg(1)})`);
         case "http.resWriteDyn":
-            emitter.line(`scr_http_res_write_dynv(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_write_dynv(${arg(0)}, ${arg(1)})`);
         case "http.resEndDyn":
-            emitter.line(`scr_http_res_end_dynv(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_end_dynv(${arg(0)}, ${arg(1)})`);
         case "http.resHeadersSent":
             return finish(`scr_http_res_headers_sent(${arg(0)})`);
+        case "http.resWritableEnded":
+            return finish(`scr_http_res_writable_ended(${arg(0)})`);
+        case "http.resFlushHeaders":
+            return finish(`scr_http_res_flush_headers(${arg(0)})`);
+        case "http.resAddTrailers":
+            return finish(`scr_http_res_add_trailers(${arg(0)}, ${arg(1)})`);
+        case "http.resCork":
+            emitter.line(`scr_http_res_cork(${arg(0)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.resUncork":
+            return finish(`scr_http_res_uncork(${arg(0)})`);
+        case "http.resWritableCorked":
+            return finish(`scr_http_res_writable_corked(${arg(0)})`);
         // The server-surface member follow-ups.
         case "http.reqStatusCode": {
             // number | undefined, type-directed like process.columns: the
@@ -5961,8 +6214,12 @@ function emitHttpLibCall(state) {
             return finish(`scr_http_req_h2_stream_or_throw(${arg(0)}, ${arg(1)})`);
         case "http.reqRawHeaders":
             return finish(`scr_http_req_raw_headers(${arg(0)})`);
+        case "http.reqRawTrailers":
+            return finish(`scr_http_req_raw_trailers(${arg(0)})`);
         case "http.reqHeaderPairs":
             return finish(`scr_http_req_header_pairs(${arg(0)})`);
+        case "http.reqTrailerPairs":
+            return finish(`scr_http_req_trailer_pairs(${arg(0)})`);
         case "http.reqStatusMessage": {
             // string | undefined: a reason phrase on client responses,
             // NULL (the undefined arm) on server requests — the
@@ -6074,6 +6331,35 @@ function emitHttpLibCall(state) {
         case "http.serverJoinDupHeaders":
             emitter.line(`scr_http_server_join_duplicate_headers(${arg(0)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
+        case "http.serverAllowMissingHostHeader":
+            emitter.line(`scr_http_server_allow_missing_host_header(${arg(0)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.serverSetTimeout":
+            emitter.line(`scr_net_server_set_timeout_plain(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.serverCloseAllConnections":
+        case "http.serverCloseIdleConnections": {
+            const entry = e.fn === "http.serverCloseAllConnections"
+                ? "scr_net_server_close_all_connections" : "scr_net_server_close_idle_connections";
+            emitter.line(`${entry}(${arg(0)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "http.serverOnTimeout":
+        case "http.serverSetTimeoutCb": {
+            const cbIndex = e.fn === "http.serverSetTimeoutCb" ? 2 : 1;
+            const cbT = e.args[cbIndex].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError(`emitter bug: ${e.fn} callback not a func`);
+            const cb = args[cbIndex];
+            emitter.moveTemp(cb);
+            const adapter = cbT.params.length === 0 ? "scr_net_conn_thunk0" : "scr_net_conn_thunk_sock";
+            const entry = e.fn === "http.serverOnTimeout" ? "scr_net_server_on_timeout" : "scr_net_server_set_timeout_cb";
+            const callArgs = e.fn === "http.serverOnTimeout"
+                ? `${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)}`
+                : `${arg(0)}, ${arg(1)}, ${cb.name}, &${adapter}`;
+            emitter.line(`${entry}(${callArgs});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "http.serverTimeoutGet":
             return finish(`scr_net_server_timeout_get(${arg(0)}, ${arg(1)})`);
         case "http.serverTimeoutSet":
@@ -6086,27 +6372,82 @@ function emitHttpLibCall(state) {
         case "http.resStatusSet":
             emitter.line(`scr_http_res_status_set(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
-        case "http.resStatusMsgGet":
-            return finish(`scr_http_res_status_msg_get(${arg(0)})`);
+        case "http.resStatusMsgGet": {
+            if (e.type.kind !== "union")
+                throw new InternalCompilerError("emitter bug: http.resStatusMsgGet result is not a union");
+            const def = emitter.unionsById.get(e.type.unionId);
+            const strTag = def ? def.arms.findIndex((a) => a.kind === "string") : -1;
+            const undefTag = undefinedArmTag(e.type, emitter.unionsById);
+            if (strTag < 0 || undefTag < 0)
+                throw new InternalCompilerError("emitter bug: http.resStatusMsgGet union lacks its arms");
+            const msg = emitter.newTemp(STRING, `scr_http_res_status_msg_get(${arg(0)})`);
+            emitter.moveTemp(msg);
+            const present = `scr_union_new_ref(${strTag}, ${msg.name}, &scr_str_retain_v, &scr_str_release_v, NULL)`;
+            return emitter.newTemp(e.type, `${msg.name} ? ${present} : ${emitter.unitInstanceRef(e.type.unionId, undefTag)}`);
+        }
         case "http.resStatusMsgSet":
             emitter.line(`scr_http_res_status_msg_set(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
-        case "http.resGetHeader": {
+        case "http.resRequest":
+            return finish(`scr_http_res_request(${arg(0)})`);
+        case "http.resSocket": {
+            if (e.type.kind !== "union")
+                throw new InternalCompilerError("emitter bug: http.resSocket result is not a union");
+            const def = emitter.unionsById.get(e.type.unionId);
+            const socketTag = def ? def.arms.findIndex((a) => a.kind === "netSocket") : -1;
+            const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
+            if (socketTag < 0 || nullTag < 0)
+                throw new InternalCompilerError("emitter bug: http.resSocket union lacks its arms");
+            const sock = emitter.newTemp(NETSOCKET_T, `scr_http_res_socket(${arg(0)})`);
+            emitter.moveTemp(sock);
+            const present = `scr_union_new_ref(${socketTag}, ${sock.name}, &scr_net_sock_retain_v, &scr_net_sock_release_v, NULL)`;
+            return emitter.newTemp(e.type, `${sock.name} ? ${present} : ${emitter.unitInstanceRef(e.type.unionId, nullTag)}`);
+        }
+        case "http.resWritableFinished":
+            return finish(`scr_http_res_writable_finished(${arg(0)})`);
+        case "http.resSendDateGet":
+            return finish(`scr_http_res_send_date(${arg(0)})`);
+        case "http.resSendDateSet":
+            emitter.line(`scr_http_res_set_send_date(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.resStrictContentLengthGet":
+            return finish(`scr_http_res_strict_content_length(${arg(0)})`);
+        case "http.resStrictContentLengthSet":
+            emitter.line(`scr_http_res_set_strict_content_length(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.resSetTimeout":
+            emitter.line(`scr_http_res_set_timeout_plain(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.resSetTimeoutCb": {
+            const cb = args[2];
+            emitter.moveTemp(cb);
+            emitter.line(`scr_http_res_set_timeout(${arg(0)}, ${arg(1)}, ${cb.name});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "http.resGetHeader":
+        case "http.clientGetHeader": {
             // string|undefined, exactly the http.reqHeader emission.
             if (e.type.kind !== "union")
-                throw new InternalCompilerError("emitter bug: http.resGetHeader result is not a union");
+                throw new InternalCompilerError(`emitter bug: ${e.fn} result is not a union`);
             const def = emitter.unionsById.get(e.type.unionId);
             const strTag = def ? def.arms.findIndex((a) => a.kind === "string") : -1;
             const undefTag = undefinedArmTag(e.type, emitter.unionsById);
             if (strTag < 0 || undefTag < 0) {
                 throw new InternalCompilerError("emitter bug: http.resGetHeader union lacks its arms");
             }
-            const s = emitter.newTemp(STRING, `scr_http_res_get_header(${arg(0)}, ${arg(1)})`);
+            const entry = e.fn === "http.resGetHeader" ? "scr_http_res_get_header" : "scr_http_client_get_header";
+            const s = emitter.newTemp(STRING, `${entry}(${arg(0)}, ${arg(1)})`);
             emitter.moveTemp(s); // moves into the box when present; NULL otherwise
             const present = `scr_union_new_ref(${strTag}, ${s.name}, &scr_str_retain_v, &scr_str_release_v, NULL)`;
             const absent = emitter.unitInstanceRef(e.type.unionId, undefTag);
             return emitter.newTemp(e.type, `${s.name} ? ${present} : ${absent}`);
         }
+        case "http.resGetHeaderNames":
+            return finish(`scr_http_res_get_header_names(${arg(0)})`);
+        case "http.resGetRawHeaderNames":
+            return finish(`scr_http_res_get_raw_header_names(${arg(0)})`);
+        case "http.resGetHeaders":
+            return finish(`scr_http_res_get_headers(${arg(0)})`);
         case "http.resHasHeader":
             return finish(`scr_http_res_has_header_named(${arg(0)}, ${arg(1)})`);
         case "http.resRemoveHeader":
@@ -6119,12 +6460,19 @@ function emitHttpLibCall(state) {
             return { name: "", type: e.type };
         }
         case "http.resWriteHeadPairs":
-            emitter.line(`scr_http_res_write_head_pairs(${arg(0)}, ${arg(1)}, ${arg(2)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_res_write_head_pairs(${arg(0)}, ${arg(1)}, ${arg(2)})`);
         case "http.resWriteHeadDyn":
             return finish(`scr_http_res_write_head_dyn(${arg(0)}, ${arg(1)}, ${arg(2)})`);
         case "http.reqSetEncoding":
             return finish(`scr_http_req_set_encoding(${arg(0)}, ${arg(1)})`);
+        case "http.reqSetTimeout":
+            return finish(`scr_http_req_set_timeout_plain(${arg(0)}, ${arg(1)})`);
+        case "http.reqSetTimeoutCb": {
+            const cb = args[2];
+            emitter.moveTemp(cb);
+            emitter.line(`scr_http_req_set_timeout(${arg(0)}, ${arg(1)}, ${cb.name});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         // node:http, the client slice (scr_http.c over the net client).
         case "http.request":
         case "http.requestCb": {
@@ -6293,29 +6641,84 @@ function emitHttpLibCall(state) {
             return finish(`(${arg(0)} ? scr_https_request(${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)}, ${arg(7)}, ${arg(8)}, (const char *)${arg(9)}->data, ${arg(9)}->len, ${cbExpr}, ${adapter}) : scr_http_request_ex(${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)}, ${arg(7)}, ${cbExpr}, ${adapter}, 80, NULL, NULL))`);
         }
         case "http.clientWrite":
-            emitter.line(`scr_http_client_write_str(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_client_write_str(${arg(0)}, ${arg(1)})`);
+        case "http.clientSetHeader":
+            return finish(`scr_http_client_set_header(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+        case "http.clientHasHeader":
+            return finish(`scr_http_client_has_header_named(${arg(0)}, ${arg(1)})`);
+        case "http.clientRemoveHeader":
+            return finish(`scr_http_client_remove_header(${arg(0)}, ${arg(1)})`);
+        case "http.clientGetHeaderNames":
+            return finish(`scr_http_client_get_header_names(${arg(0)})`);
+        case "http.clientGetRawHeaderNames":
+            return finish(`scr_http_client_get_raw_header_names(${arg(0)})`);
+        case "http.clientGetHeaders":
+            return finish(`scr_http_client_get_headers(${arg(0)})`);
         case "http.clientWriteBytes":
-            emitter.line(`scr_http_client_write_bytes(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_client_write_bytes(${arg(0)}, ${arg(1)})`);
         case "http.clientEnd":
-            emitter.line(`scr_http_client_end(${arg(0)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_client_end(${arg(0)})`);
         case "http.clientEndStr":
-            emitter.line(`scr_http_client_end_str(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_client_end_str(${arg(0)}, ${arg(1)})`);
         case "http.clientEndBytes":
-            emitter.line(`scr_http_client_end_bytes(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_client_end_bytes(${arg(0)}, ${arg(1)})`);
         case "http.clientWriteDyn":
-            emitter.line(`scr_http_client_write_dynv(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
-            return { name: "", type: e.type };
+            return finish(`scr_http_client_write_dynv(${arg(0)}, ${arg(1)})`);
         case "http.clientEndDyn":
-            emitter.line(`scr_http_client_end_dynv(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return finish(`scr_http_client_end_dynv(${arg(0)}, ${arg(1)})`);
+        case "http.clientFlushHeaders":
+            return finish(`scr_http_client_flush_headers(${arg(0)})`);
+        case "http.clientAddTrailers":
+            return finish(`scr_http_client_add_trailers(${arg(0)}, ${arg(1)})`);
+        case "http.clientCork":
+            emitter.line(`scr_http_client_cork(${arg(0)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.clientUncork":
+            return finish(`scr_http_client_uncork(${arg(0)})`);
+        case "http.clientWritableCorked":
+            return finish(`scr_http_client_writable_corked(${arg(0)})`);
+        case "http.clientMethod":
+            return finish(`scr_http_client_method(${arg(0)})`);
+        case "http.clientPath":
+            return finish(`scr_http_client_path(${arg(0)})`);
+        case "http.clientHost":
+            return finish(`scr_http_client_host(${arg(0)})`);
+        case "http.clientProtocol":
+            return finish(`scr_http_client_protocol(${arg(0)})`);
+        case "http.clientHeadersSent":
+            return finish(`scr_http_client_headers_sent(${arg(0)})`);
+        case "http.clientWritableEnded":
+            return finish(`scr_http_client_writable_ended(${arg(0)})`);
+        case "http.clientWritableFinished":
+            return finish(`scr_http_client_writable_finished(${arg(0)})`);
+        case "http.clientSocket":
+            return finish(`scr_http_client_socket(${arg(0)})`);
+        case "http.clientReusedSocket":
+            return finish(`scr_http_client_reused_socket(${arg(0)})`);
+        case "http.clientSetNoDelay":
+            return finish(`scr_http_client_set_nodelay(${arg(0)}, ${arg(1)})`);
+        case "http.clientSetSocketKeepAlive":
+            return finish(`scr_http_client_set_socket_keepalive(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+        case "http.clientSetTimeout":
+            return finish(`scr_http_client_set_timeout(${arg(0)}, ${arg(1)})`);
+        case "http.clientSetTimeoutCb": {
+            const cb = args[2];
+            emitter.moveTemp(cb);
+            emitter.line(`scr_http_client_set_timeout_cb(${arg(0)}, ${arg(1)}, ${cb.name});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
+        }
+        case "http.statusCodes":
+            return finish("scr_http_status_codes()");
+        case "http.methods":
+            return finish("scr_http_methods()");
         case "http.clientDestroy":
             emitter.line(`scr_http_client_destroy(${arg(0)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
+        case "http.clientAbort":
+            emitter.line(`scr_http_client_abort(${arg(0)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.clientAborted":
+            return finish(`scr_http_client_aborted(${arg(0)})`);
         case "http.clientDestroyed":
             return finish(`scr_http_client_destroyed(${arg(0)})`);
         case "http.clientOnResponse": {
@@ -6328,6 +6731,16 @@ function emitHttpLibCall(state) {
             emitter.line(`scr_http_client_on_response(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
+        case "http.clientOnSocket": {
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: http.clientOnSocket callback not a func");
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            const adapter = cbT.params.length === 0 ? "scr_net_conn_thunk0" : "scr_net_conn_thunk_sock";
+            emitter.line(`scr_http_client_on_socket(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "http.clientOnError": {
             const cbT = e.args[1].type;
             if (cbT.kind !== "func")
@@ -6339,10 +6752,14 @@ function emitHttpLibCall(state) {
             return { name: "", type: e.type };
         }
         case "http.clientOnTimeout":
-        case "http.clientOnClose": {
+        case "http.clientOnClose":
+        case "http.clientOnFinish":
+        case "http.clientOnAbort": {
             const cb = args[1];
             emitter.moveTemp(cb);
-            const fn = e.fn === "http.clientOnTimeout" ? "scr_http_client_on_timeout" : "scr_http_client_on_close";
+            const fn = e.fn === "http.clientOnTimeout" ? "scr_http_client_on_timeout"
+                : e.fn === "http.clientOnClose" ? "scr_http_client_on_close"
+                    : e.fn === "http.clientOnAbort" ? "scr_http_client_on_abort" : "scr_http_client_on_finish";
             emitter.line(`${fn}(${arg(0)}, ${cb.name}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
@@ -7126,6 +7543,45 @@ function emitProcessLibCall(state) {
             return finish(`scr_process_getgid()`);
         case "process.execPath":
             return finish(`scr_process_exec_path()`);
+        case "process.forkTarget":
+            return finish(`scr_process_fork_target(${arg(0)})`);
+        case "process.connected":
+            return finish(`scr_process_ipc_connected()`);
+        case "process.send":
+            emitter.usesTimers = true;
+            return finish(`scr_process_ipc_send(${arg(0)})`);
+        case "process.sendCb": {
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: process.send callback not a func");
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            emitter.usesTimers = true;
+            return finish(`scr_process_ipc_send_cb(${arg(0)}, ${cb.name}, &${emitter.ipcSendThunkFor(cbT)})`);
+        }
+        case "process.disconnect":
+            emitter.usesTimers = true;
+            return finish(`scr_process_ipc_disconnect()`);
+        case "process.onMessage": {
+            const cbT = e.args[0].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: process message listener not a func");
+            const cb = args[0];
+            emitter.moveTemp(cb);
+            emitter.usesTimers = true;
+            emitter.line(`scr_process_ipc_on_message(${cb.name}, &${emitter.ipcMessageThunkFor(cbT)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "process.onDisconnect": {
+            const cbT = e.args[0].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: process disconnect listener not a func");
+            const cb = args[0];
+            emitter.moveTemp(cb);
+            emitter.usesTimers = true;
+            emitter.line(`scr_process_ipc_on_disconnect(${cb.name}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "process.arch":
             return finish(`scr_process_arch()`);
         case "process.versionsNode":
@@ -7149,6 +7605,10 @@ function emitProcessLibCall(state) {
             // Flushes stdout and _Exit()s — never returns (exit handlers,
             // including the RC audit, deliberately do not run).
             return finish(`scr_process_exit(${arg(0)})`);
+        case "process.setExitCode":
+            return finish(`scr_process_set_exit_code(${arg(0)})`);
+        case "process.currentExitCode":
+            return finish(`scr_process_exit_code_or_zero()`);
         case "process.nextTick": {
             // The tick queue owns the callback until the drain fires it;
             // ticks run before promise jobs at every loop checkpoint and
@@ -7362,6 +7822,8 @@ function emitErrorsEventsLibCall(state) {
             const dynThunk = emitter.emitterInvokeThunkFor(adT);
             return finish(`(${cType(e.type).trim()})scr_emitter_on_dyn((ScrEmitter *)${arg(0)}, ${arg(1)}, ${arg(2)}, ${adapter.name}, &${dynThunk}, ${arg(4)}, ${arg(5)})`);
         }
+        case "emitter.onFlex":
+            return finish(`(${cType(e.type).trim()})scr_emitter_on_flex((ScrEmitter *)${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)})`);
         case "emitter.onData": {
             // The stream-'data' registration: same runtime entry as
             // emitter.on, but the DATA invoke thunk (the two-slot payload
@@ -7401,6 +7863,13 @@ function emitErrorsEventsLibCall(state) {
             // C variadic tail, every argument borrowed (the invoke
             // adapters retain each callee's +1). May-throw (listeners).
             return finish(`scr_emitter_emit((ScrEmitter *)${arg(0)}, ${arg(1)}${e.args.slice(2).map((_, i) => `, ${arg(i + 2)}`).join("")})`);
+        case "emitter.emitFlex": {
+            const count = e.args.length - 2;
+            const payload = count === 0
+                ? "NULL"
+                : `(ScrDyn *const[]){${e.args.slice(2).map((_, i) => arg(i + 2)).join(", ")}}`;
+            return finish(`scr_emitter_emit_flex((ScrEmitter *)${arg(0)}, ${arg(1)}, ${payload}, ${count})`);
+        }
         case "emitter.emitError":
             // emit('error', err): unhandled ⇒ the runtime throws the
             // payload through the exception cell (may-throw seed).
@@ -7479,12 +7948,25 @@ function emitStreamLibCall(state) {
             emitter.line(`scr_child_stream_on_data(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
+        case "stream.onDataStr": {
+            emitter.usesTimers = true;
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func" || cbT.params[0]?.kind !== "string") {
+                throw new InternalCompilerError("emitter bug: stream.onDataStr callback not a string func");
+            }
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            emitter.line(`scr_child_stream_on_data_str(${arg(0)}, ${cb.name}, &scr_child_stream_thunk_str, ${arg(2)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "stream.onEnd": {
             const cb = args[1];
             emitter.moveTemp(cb);
             emitter.line(`scr_child_stream_on_end(${arg(0)}, ${cb.name}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
+        case "stream.childSetEncoding":
+            return finish(`scr_child_stream_set_encoding(${arg(0)}, ${arg(1)})`);
         // node:stream (scr_stream.c — linked exactly when these appear,
         // moduleUsesStream). Receivers reinterpret to the shared
         // ScrStream layout (the ScrEmitter prefix plus the stream-state
@@ -7895,6 +8377,8 @@ function emitAssertInspectLibCall(state) {
             // The quartet over checked-dynamic operands: SameValue /
             // dyn-walk deep equality, assertion_error.js messages.
             return finish(`scr_assert_eq_dyn(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
+        case "assert.looseResult":
+            return finish(`scr_assert_loose_result(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
         case "assert.deepResult":
             return finish(`scr_assert_deep_result(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
         case "assert.deqEnter":
@@ -8175,6 +8659,7 @@ export function emitExpr(emitter, e) {
         case "numLit":
         case "boolLit":
         case "strLit":
+        case "moduleNsRef":
         case "unitLit":
         case "varRef":
             return emitLiteralExpr(emitter, e);