@scriptc/compiler 0.1.3 → 0.1.4

package/dist/frontend/lowering/lower-builtins.js

@@ -7,14 +7,14 @@ import { builtinModules } from "node:module";
 import { dirname, resolve } from "node:path";
 import * as ts from "../ts7/adapter.js";
 import { PoisonError, dynUndefinedExpr, ladderFenceExpr, nodeThrowExpr, own } from "./lowerer.js";
-import { canonicalBuiltinModule, isJsSourceFile, isNodeEsmFile, locOf, requireSpecOf } from "../program.js";
+import { canonicalBuiltinModule, isJsSourceFile, isNodeEsmFile, locOf, npmStaticDepSf7, requireSpecOf, resolveImport } from "../program.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { probeNodeRequireRefusal } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
 import { trackedReadFile } from "../input-tracker.js";
 import { requireResolvePathsRuntime, resolveImportMetaRuntime, resolveRequireRuntime } from "../runtime-resolve.js";
 import { invalidJsonModuleDiag, requiresDynamicImportDiag } from "../../diagnostics/diagnostic.js";
-import { builtinModuleFnOf, FS_READDIR_DOCUMENTED_OPTIONS, FS_WATCH_DOCUMENTED_OPTIONS, FS_WRITE_FILE_DOCUMENTED_OPTIONS, QS_PARSE_DOCUMENTED_OPTIONS, QS_STRINGIFY_DOCUMENTED_OPTIONS, READLINE_DOCUMENTED_OPTIONS, builtinConstLit, fenceOrDropOptionKey, isChildSurfaceMember, } from "./surfaces.js";
+import { builtinModuleFnOf, FS_READDIR_DOCUMENTED_OPTIONS, FS_WATCH_DOCUMENTED_OPTIONS, FS_WRITE_FILE_DOCUMENTED_OPTIONS, QS_PARSE_DOCUMENTED_OPTIONS, QS_STRINGIFY_DOCUMENTED_OPTIONS, READLINE_DOCUMENTED_OPTIONS, builtinConstLit, fenceOrDropOptionKey, isChildSurfaceMember, NODE_BUILTIN_MODULES_V24, } from "./surfaces.js";
 import { lowerAbsenceProbe } from "./lower-exprs.js";
 import { conditionalSpreadOf, lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
@@ -24,8 +24,11 @@ import { CRYPTO_CIPHERS, CRYPTO_CONSTANTS, CRYPTO_CURVES, CRYPTO_HASHES } from "
 import { generatorMeta, timerStyleCallback } from "./lower-calls.js";
 import { registerHttpClientFnBinding, voidizedCallback } from "./lower-server.js";
 import { pairsSnapshotHelper } from "./pairs-snapshot.js";
+import { bufEncoding } from "./containers/bytes.js";
 import { BOOL, BYTES_U8, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DYN, F64, FILEHANDLE_T, FSWATCHER_T, PROCSTREAM_T, JSVAL, NULL_T, SEARCH_PARAMS_T, SPAWNRES_T, STRING, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, funcOf, isUnitType, typeEquals, typeKey } from "../../ir/ir.js";
 import { boolLit, countedFor, numLit, strLit, varRef } from "../../ir/build.js";
+import { staticForkModulePath } from "../fork-target.js";
+import { tsgoPath } from "../dts-paths.js";
 function optionalStringTags(lowerer, type) {
     if (type.kind !== "union")
         return null;
@@ -439,6 +442,108 @@ export function createRequireNamespaceDecl(lowerer, nameNode, init) {
     const cr = createRequireSpecOf(lowerer, call);
     return cr !== null && cr.spec !== null && canonicalBuiltinModule(cr.spec) !== null;
 }
+/** A statically compiled program module reached through a canonical
+   * createRequire binding. This is the ESM twin of an ordinary CommonJS
+   * require edge: the same project resolver, require-condition npm-static
+   * entry, module initializer, and export registrations own the target. */
+export function createRequireProgramModuleOf(lowerer, expr) {
+    if (expr === undefined)
+        return null;
+    const call = stripTypeCasts(expr);
+    if (!ts.isCallExpression(call))
+        return null;
+    const cr = createRequireSpecOf(lowerer, call);
+    if (cr === null || cr.spec === null || canonicalBuiltinModule(cr.spec) !== null)
+        return null;
+    const dep = resolveImport(lowerer.program, cr.baseFile, cr.spec) ??
+        npmStaticDepSf7(lowerer.program, cr.baseFile, cr.spec);
+    if (dep === null || dep.fileName.endsWith(".json"))
+        return null;
+    return { spec: cr.spec, baseFile: cr.baseFile, dep };
+}
+/** True for a const identifier whose initializer is a createRequire call
+   * reaching a compiled program module. The binding is namespace/value
+   * alias plumbing; its declaration emits only the dependency's run-once
+   * initializer at the source position. */
+export function createRequireProgramModuleDecl(lowerer, nameNode, init) {
+    if (createRequireProgramModuleOf(lowerer, init) === null)
+        return false;
+    if (ts.isIdentifier(nameNode))
+        return true;
+    if (!ts.isObjectBindingPattern(nameNode))
+        return false;
+    return nameNode.elements.every((element) => element.name !== undefined && element.dotDotDotToken === undefined && element.initializer === undefined &&
+        ts.isIdentifier(element.name) &&
+        (element.propertyName === undefined || ts.isIdentifier(element.propertyName) || ts.isStringLiteralLike(element.propertyName)));
+}
+/** node:module's two compiler-only calls. isBuiltin compares one evaluated
+   * string against the pinned Node 24 list (bare builtins also accept their
+   * node: spelling; prefix-only entries do not gain a bare alias).
+   * syncBuiltinESMExports is observably a no-op inside the static surface:
+   * builtin exports cannot be mutated, so its only supported behavior is
+   * evaluating no arguments and returning undefined. */
+export function lowerNodeModuleCall(lowerer, expr, bi, loc) {
+    if (bi.module !== "module")
+        return null;
+    if (bi.member === "syncBuiltinESMExports") {
+        if (expr.arguments.length !== 0 || expr.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`module.syncBuiltinESMExports with ${expr.arguments.length} arguments`, expr, "syncBuiltinESMExports() takes no arguments");
+        }
+        if (!ts.isExpressionStatement(expr.parent)) {
+            lowerer.noLowering("module.syncBuiltinESMExports used as a value", expr, "call syncBuiltinESMExports() as its own statement; the supported static effect is a no-op");
+        }
+        return { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc };
+    }
+    if (bi.member !== "isBuiltin")
+        return null;
+    if (expr.arguments.length !== 1 || expr.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`module.isBuiltin with ${expr.arguments.length} arguments`, expr, "isBuiltin(moduleName) takes one string");
+    }
+    const argumentNode = expr.arguments[0];
+    const argument = lowerer.lowerExpr(argumentNode);
+    if (argument.type.kind !== "string") {
+        if (argument.type.kind === "dyn" || argument.type.kind === "jsval" || argument.type.kind === "union") {
+            lowerer.noLowering("module.isBuiltin with a runtime-polymorphic argument", argumentNode, "narrow the module name to a string first; statically non-string values return false");
+        }
+        return {
+            kind: "seqExpr",
+            stmts: [{ kind: "exprStmt", expr: argument, loc: locOf(argumentNode) }],
+            result: boolLit(false, loc),
+            type: BOOL,
+            loc,
+        };
+    }
+    const slot = lowerer.declareHiddenLocal("%builtinName", STRING);
+    const ref = () => varRef(slot.id, STRING, loc);
+    const accepted = NODE_BUILTIN_MODULES_V24.flatMap((name) => name.startsWith("node:") ? [name] : [name, `node:${name}`]);
+    let staticArgument = argumentNode;
+    while (ts.isParenthesizedExpression(staticArgument) || ts.isAsExpression(staticArgument) ||
+        ts.isTypeAssertion(staticArgument) || ts.isNonNullExpression(staticArgument)) {
+        staticArgument = staticArgument.expression;
+    }
+    if (ts.isStringLiteralLike(staticArgument)) {
+        return boolLit(accepted.includes(staticArgument.text), loc);
+    }
+    let result = boolLit(false, loc);
+    for (let i = accepted.length - 1; i >= 0; i--) {
+        const equal = {
+            kind: "strEq",
+            negated: false,
+            left: ref(),
+            right: strLit(accepted[i], loc),
+            type: BOOL,
+            loc,
+        };
+        result = { kind: "logical", op: "||", left: equal, right: result, type: BOOL, loc };
+    }
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "varDecl", localId: slot.id, init: argument, loc }],
+        result,
+        type: BOOL,
+        loc,
+    };
+}
 /** `require("spec")` through a createRequire binding — the erasure per
    * target. Builtins are reached here only OUTSIDE the const-namespace-
    * binding shape (that declaration erases; member uses resolve through
@@ -465,12 +570,16 @@ export function lowerCreateRequireCall(lowerer, call, loc) {
     if (canonicalBuiltinModule(spec) !== null) {
         lowerer.unsupported("SC1090", call, `module namespace objects as values (bind it first: const m = require("${spec}"), then access members through the binding)`);
     }
+    const programModule = createRequireProgramModuleOf(lowerer, call);
+    if (programModule !== null) {
+        lowerer.noLowering(`createRequire's module namespace value for '${spec}'`, call, `bind it once (const m = require(${JSON.stringify(spec)})) and access statically-known members through that binding`);
+    }
     if (spec.startsWith("#")) {
         lowerer.noLowering(`createRequire's require of the '${spec}' project import`, call, "imports-field specifiers have no require lowering yet — import the target statically");
     }
     if (isRelativeSpecifier(spec) || spec.startsWith("/")) {
         if (!spec.endsWith(".json")) {
-            lowerer.noLowering(`createRequire's require of '${spec}'`, call, "relative requires lower for .json documents only — a program module is a static import");
+            lowerer.noLowering(`createRequire's require of '${spec}'`, call, "relative program modules lower when they resolve into the compiled graph; relative .json documents bake at build time");
         }
         const abs = spec.startsWith("/")
             ? spec
@@ -891,6 +1000,86 @@ function optionMember(p) {
     }
     return null;
 }
+/** Normalize fs.readSync/fs.writeSync's shorthand and inline-options buffer
+ * forms into the existing fixed-width descriptor IR. fd and buffer bind
+ * first, option values bind in object-literal order, and only then do the
+ * default window expressions read the bound buffer length. */
+function lowerFsSyncBufferWindow(lowerer, expr, loc, fn, source, supported) {
+    const fdValue = lowerer.lowerExprExpecting(expr.arguments[0], F64);
+    const bufferValue = lowerer.lowerExprExpecting(expr.arguments[1], BYTES_U8);
+    const fdLocal = lowerer.declareHiddenLocal("%fsSyncFd", F64);
+    const bufferLocal = lowerer.declareHiddenLocal("%fsSyncBuffer", BYTES_U8);
+    const stmts = [
+        { kind: "varDecl", localId: fdLocal.id, init: fdValue, loc: fdValue.loc },
+        { kind: "varDecl", localId: bufferLocal.id, init: bufferValue, loc: bufferValue.loc },
+    ];
+    const fd = () => varRef(fdLocal.id, fdLocal.type, loc);
+    const buffer = () => varRef(bufferLocal.id, bufferLocal.type, loc);
+    const number = (value) => numLit(value, loc);
+    const stageNumber = (name, node) => {
+        const mapped = lowerer.mapTypeOf(lowerer.typeOf(node));
+        if (mapped?.kind !== "f64") {
+            lowerer.noLowering(`${fn} with a '${mapped ? lowerer.fmt(mapped) : lowerer.checker.typeToString(lowerer.typeOf(node))}' ${name}`, node, supported);
+        }
+        const value = lowerer.lowerExprExpecting(node, F64);
+        const local = lowerer.declareHiddenLocal(`%fsSync${name}`, F64);
+        stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc });
+        return varRef(local.id, local.type, loc);
+    };
+    const isNull = (node) => {
+        let value = node;
+        while (ts.isParenthesizedExpression(value))
+            value = value.expression;
+        return value.kind === ts.SyntaxKind.NullKeyword;
+    };
+    let offset = null;
+    let length = null;
+    let position = null;
+    if (source.kind === "offset") {
+        offset = stageNumber("offset", source.node);
+    }
+    else if (source.node !== undefined && !isNull(source.node)) {
+        if (!ts.isObjectLiteralExpression(source.node)) {
+            lowerer.noLowering(`${fn} with a non-literal options argument`, source.node, supported);
+        }
+        for (const property of source.node.properties) {
+            const member = optionMember(property);
+            if (member === null) {
+                lowerer.noLowering(`${fn} with a non-plain options member`, property, supported);
+            }
+            if (member.name === "offset") {
+                offset = stageNumber("offset", member.value);
+            }
+            else if (member.name === "length") {
+                length = stageNumber("length", member.value);
+            }
+            else if (member.name === "position") {
+                position = isNull(member.value) ? null : stageNumber("position", member.value);
+            }
+            else {
+                const effect = lowerer.lowerExpr(member.value);
+                stmts.push({ kind: "exprStmt", expr: effect, loc: effect.loc });
+            }
+        }
+    }
+    const normalizedOffset = offset ?? number(0);
+    const normalizedLength = length ?? {
+        kind: "bin",
+        op: "-",
+        left: { kind: "bytesIntrinsic", method: "length", receiver: buffer(), args: [], type: F64, loc },
+        right: normalizedOffset,
+        type: F64,
+        loc,
+    };
+    const result = {
+        kind: "libCall",
+        fn,
+        args: [fd(), buffer(), normalizedOffset, normalizedLength, position ?? number(-1)],
+        type: F64,
+        loc,
+    };
+    return { kind: "seqExpr", stmts, result, type: F64, loc };
+}
 /** One builtin-module function call → its libCall. Completes the call to
    * the table's exact shape: variadicPack functions (path.join/resolve)
    * accept any arity — or ONE spread of a string[] — and pack the
@@ -1061,14 +1250,152 @@ export function lowerFsLadderCall(lowerer, expr, bi, loc) {
             return null;
     }
 }
+const ZLIB_SYNC_FNS = {
+    deflateSync: "zlib.deflateSync",
+    inflateSync: "zlib.inflateSync",
+    deflateRawSync: "zlib.deflateRawSync",
+    inflateRawSync: "zlib.inflateRawSync",
+    gzipSync: "zlib.gzipSync",
+    gunzipSync: "zlib.gunzipSync",
+    unzipSync: "zlib.unzipSync",
+};
+const ZLIB_CALLBACK_FNS = {
+    deflate: "zlib.deflateCb",
+    inflate: "zlib.inflateCb",
+    deflateRaw: "zlib.deflateRawCb",
+    inflateRaw: "zlib.inflateRawCb",
+    gzip: "zlib.gzipCb",
+    gunzip: "zlib.gunzipCb",
+    unzip: "zlib.unzipCb",
+};
+function zlibInputBytes(lowerer, node, loc) {
+    const value = lowerer.lowerExpr(node);
+    if (value.type.kind === "bytes" && value.type.elem === "u8")
+        return value;
+    if (value.type.kind === "string") {
+        return {
+            kind: "libCall",
+            fn: "buffer.fromStr",
+            args: [value, { kind: "strLit", value: "utf8", type: STRING, loc }],
+            type: BYTES_U8,
+            loc,
+        };
+    }
+    lowerer.noLowering(`zlib byte input of '${lowerer.fmt(value.type)}' values`, node, "string and Buffer/Uint8Array values are supported");
+}
+function lowerZlibModuleCall(lowerer, expr, bi, loc) {
+    if (expr.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`zlib.${bi.member} with spread arguments`, expr);
+    }
+    const syncFn = ZLIB_SYNC_FNS[bi.member];
+    if (syncFn !== undefined) {
+        if (expr.arguments.length !== 1) {
+            const site = expr.arguments[1] ?? expr;
+            lowerer.noLowering(`${bi.member} with explicit options`, site, `${bi.member}(data) with Node's default options is supported`);
+        }
+        return {
+            kind: "libCall",
+            fn: syncFn,
+            args: [zlibInputBytes(lowerer, expr.arguments[0], loc)],
+            type: BYTES_U8,
+            loc,
+        };
+    }
+    const callbackFn = ZLIB_CALLBACK_FNS[bi.member];
+    if (callbackFn !== undefined) {
+        if (expr.arguments.length !== 2) {
+            const site = expr.arguments.length >= 3 ? expr.arguments[1] : expr;
+            lowerer.noLowering(`${bi.member} with ${expr.arguments.length} arguments`, site, `${bi.member}(data, callback) with Node's default options is supported; explicit options are not yet lowered`);
+        }
+        return {
+            kind: "libCall",
+            fn: callbackFn,
+            args: [
+                zlibInputBytes(lowerer, expr.arguments[0], loc),
+                errorFirstBytesCallback(lowerer, expr.arguments[1], "zlib"),
+            ],
+            type: VOID,
+            loc,
+        };
+    }
+    if (bi.member === "crc32") {
+        if (expr.arguments.length < 1 || expr.arguments.length > 2) {
+            lowerer.noLowering(`zlib.crc32 with ${expr.arguments.length} arguments`, expr, "crc32(data[, initialValue]) is supported");
+        }
+        return {
+            kind: "libCall",
+            fn: "zlib.crc32",
+            args: [
+                zlibInputBytes(lowerer, expr.arguments[0], loc),
+                expr.arguments[1]
+                    ? lowerer.lowerExprExpecting(expr.arguments[1], F64)
+                    : { kind: "numLit", value: 0, type: F64, loc },
+            ],
+            type: F64,
+            loc,
+        };
+    }
+    throw new InternalCompilerError(`unhandled lowered zlib member ${bi.member}`);
+}
 export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     const name = expr.expression.getText();
+    // Numeric open flags are interpreted symbolically at the call site. The
+    // O_* bit values differ between Darwin and Linux, so emit a stable mask
+    // and let the target runtime select its own native constants.
+    if (bi.module === "fs" && bi.member === "openSync" && expr.arguments.length >= 2 &&
+        lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]))?.kind === "f64") {
+        if (expr.arguments.length > 3 || expr.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering("openSync with numeric flags and this argument shape", expr);
+        }
+        const bits = {
+            O_RDONLY: 0, O_WRONLY: 1, O_RDWR: 2, O_CREAT: 4, O_EXCL: 8,
+            O_NOFOLLOW: 16, O_NONBLOCK: 32, O_TRUNC: 64, O_APPEND: 128,
+        };
+        const flagsOf = (input) => {
+            let node = input;
+            while (ts.isParenthesizedExpression(node) || ts.isAsExpression(node))
+                node = node.expression;
+            if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarToken) {
+                const left = flagsOf(node.left);
+                const right = flagsOf(node.right);
+                return left === null || right === null ? null : left | right;
+            }
+            if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+                const imported = lowerer.builtinImportOf(node.expression);
+                if (imported?.module === "fs" && imported.member === "constants") {
+                    return bits[node.name.text] ?? null;
+                }
+            }
+            if (ts.isPropertyAccessExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+                const imported = lowerer.builtinMemberOf(node.expression);
+                if (imported?.module === "fs" && imported.member === "constants") {
+                    return bits[node.name.text] ?? null;
+                }
+            }
+            return null;
+        };
+        const mask = flagsOf(expr.arguments[1]);
+        if (mask === null) {
+            lowerer.noLowering("openSync with computed numeric flags", expr.arguments[1], "use an inline bitwise OR of fs.constants.O_RDONLY/O_WRONLY/O_RDWR/O_CREAT/O_EXCL/O_NOFOLLOW/O_NONBLOCK/O_TRUNC/O_APPEND");
+        }
+        const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+        const mode = expr.arguments[2]
+            ? lowerer.lowerExprExpecting(expr.arguments[2], F64)
+            : { kind: "numLit", value: 0o666, type: F64, loc };
+        return { kind: "libCall", fn: "fs.openNumericSync", args: [path,
+                { kind: "numLit", value: mask, type: F64, loc }, mode], type: F64, loc };
+    }
+    if (bi.module === "zlib")
+        return lowerZlibModuleCall(lowerer, expr, bi, loc);
     if (bi.module === "child_process" && bi.member === "spawnSync") {
         return lowerer.lowerSpawnSyncCall(expr, loc);
     }
     if (bi.module === "child_process" && bi.member === "spawn") {
         return lowerer.lowerSpawnCall(expr, loc);
     }
+    if (bi.module === "child_process" && bi.member === "fork") {
+        return lowerForkCall(lowerer, expr, loc);
+    }
     if (bi.module === "fs" && bi.member === "watch") {
         return lowerFsWatchCall(lowerer, expr, loc);
     }
@@ -1148,18 +1475,29 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
         callback = voidizedCallback(lowerer, callback, locOf(expr.arguments[2]));
         return { kind: "libCall", fn: "fs.renameCb", args: [oldPath, newPath, callback], type: VOID, loc };
     }
-    // fs.readSync(fd, buffer, offset, length[, position]) — normalize the
-    // current-offset forms to Node/libuv's -1 sentinel so the IR and native
-    // ABI stay fixed-width. A real numeric position is a positioned read
-    // and therefore must not advance the descriptor. Literal null is the
-    // documented current-offset spelling; richer nullable expressions must
-    // narrow first so no effectful evaluation is silently discarded.
+    // fs.readSync's classic and options-object buffer forms normalize into
+    // one fixed-width IR call. Current-offset forms use Node/libuv's -1
+    // sentinel; a numeric position performs offset-preserving I/O.
     if (bi.module === "fs" && bi.member === "readSync") {
-        const supported = "use readSync(fd, buffer, offset, length[, position]) with a numeric position or literal null; options objects and bigint positions have no lowering";
-        if ((expr.arguments.length !== 4 && expr.arguments.length !== 5) ||
+        const supported = "use readSync(fd, buffer), readSync(fd, buffer, { offset?, length?, position? }), or readSync(fd, buffer, offset, length[, position]); bigint positions and non-literal options objects have no lowering";
+        if (expr.arguments.length < 2 ||
+            expr.arguments.length > 5 ||
             expr.arguments.some(ts.isSpreadElement)) {
             lowerer.noLowering(`readSync with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr, supported);
         }
+        if (expr.arguments.length === 2) {
+            return lowerFsSyncBufferWindow(lowerer, expr, loc, "fs.readSync", { kind: "options", node: undefined }, supported);
+        }
+        if (expr.arguments.length === 3) {
+            const optionsNode = expr.arguments[2];
+            let valueNode = optionsNode;
+            while (ts.isParenthesizedExpression(valueNode))
+                valueNode = valueNode.expression;
+            if (ts.isObjectLiteralExpression(valueNode) || valueNode.kind === ts.SyntaxKind.NullKeyword) {
+                return lowerFsSyncBufferWindow(lowerer, expr, loc, "fs.readSync", { kind: "options", node: valueNode }, supported);
+            }
+            lowerer.noLowering("readSync with a non-literal options argument", optionsNode, supported);
+        }
         const args = [
             lowerer.lowerExprExpecting(expr.arguments[0], F64),
             lowerer.lowerExprExpecting(expr.arguments[1], BYTES_U8),
@@ -1183,20 +1521,18 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
         }
         return { kind: "libCall", fn: "fs.readSync", args, type: F64, loc };
     }
-    // fs.writeSync has two static families. Buffer writes use the classic
-    // (fd, buffer, offset, length[, position]) shape; string writes accept
-    // (fd, string[, position[, "utf8"]]). The runtime uses -1 for the
-    // current-offset forms. Node treats a negative, fractional, non-finite,
-    // or over-MAX_SAFE numeric write position like null rather than throwing;
-    // preserve the value here so the runtime can make that dispatch.
+    // fs.writeSync has buffer and string families. Buffer writes accept
+    // omitted offset/length and inline options; string writes accept
+    // (fd, string[, position[, "utf8"]]). The runtime uses -1 for current
+    // offset. Invalid numeric WRITE positions intentionally reach the
+    // runtime, where Node normalizes them to the current descriptor offset.
     if (bi.module === "fs" && bi.member === "writeSync") {
-        const supported = 'use writeSync(fd, buffer, offset, length[, position]) or writeSync(fd, string[, position[, "utf8"]]); options objects, bigint positions, and other encodings have no lowering';
+        const supported = 'use writeSync(fd, buffer[, offset[, length[, position]]]), writeSync(fd, buffer, { offset?, length?, position? }), or writeSync(fd, string[, position[, "utf8"]]); non-literal options objects, bigint positions, and other encodings have no lowering';
         if (expr.arguments.some(ts.isSpreadElement) || expr.arguments.length < 2) {
             lowerer.noLowering(`writeSync with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr, supported);
         }
         const dataNode = expr.arguments[1];
         const dataType = lowerer.mapTypeOf(lowerer.typeOf(dataNode));
-        const fd = lowerer.lowerExprExpecting(expr.arguments[0], F64);
         const position = (node) => {
             let valueNode = node;
             while (valueNode && ts.isParenthesizedExpression(valueNode))
@@ -1214,9 +1550,26 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
             if (dataType.elem !== "u8") {
                 lowerer.noLowering(`writeSync of '${lowerer.fmt(dataType)}' data`, dataNode, "byte writes take Uint8Array/Buffer data");
             }
+            if (expr.arguments.length === 2) {
+                return lowerFsSyncBufferWindow(lowerer, expr, loc, "fs.writeSync", { kind: "options", node: undefined }, supported);
+            }
+            if (expr.arguments.length === 3) {
+                const thirdNode = expr.arguments[2];
+                let valueNode = thirdNode;
+                while (ts.isParenthesizedExpression(valueNode))
+                    valueNode = valueNode.expression;
+                if (ts.isObjectLiteralExpression(valueNode) || valueNode.kind === ts.SyntaxKind.NullKeyword) {
+                    return lowerFsSyncBufferWindow(lowerer, expr, loc, "fs.writeSync", { kind: "options", node: valueNode }, supported);
+                }
+                if (lowerer.mapTypeOf(lowerer.typeOf(thirdNode))?.kind === "f64") {
+                    return lowerFsSyncBufferWindow(lowerer, expr, loc, "fs.writeSync", { kind: "offset", node: thirdNode }, supported);
+                }
+                lowerer.noLowering("writeSync of Buffer data with a non-numeric offset", thirdNode, supported);
+            }
             if (expr.arguments.length !== 4 && expr.arguments.length !== 5) {
                 lowerer.noLowering(`writeSync of Buffer data with ${expr.arguments.length} arguments`, expr, supported);
             }
+            const fd = lowerer.lowerExprExpecting(expr.arguments[0], F64);
             return {
                 kind: "libCall",
                 fn: "fs.writeSync",
@@ -1247,6 +1600,7 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
                 // a call/getter whose type is the accepted literal cannot vanish.
                 enc = lowerer.lowerExprExpecting(encNode, STRING);
             }
+            const fd = lowerer.lowerExprExpecting(expr.arguments[0], F64);
             return {
                 kind: "libCall",
                 fn: "fs.writeStrSync",
@@ -1264,14 +1618,17 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     if (bi.module === "os" && bi.member === "networkInterfaces") {
         return lowerOsNetworkInterfacesCall(lowerer, expr, loc);
     }
-    // fs.readdirSync(path, { withFileTypes: true }) — the Dirent form:
-    // routed BEFORE the 1-arg table completion. The options must be an
-    // object literal with withFileTypes: true (encoding "utf8"/"utf-8" is
-    // accepted as the default it is; recursive and encoding:'buffer'
-    // fence), and the call site's mapped type must be the interned Dirent
-    // record array (type-mapper.ts) — the userInfo verification stance.
-    if (bi.module === "fs" && bi.member === "readdirSync" && expr.arguments.length === 2) {
-        return lowerFsReaddirTypesCall(lowerer, expr, loc);
+    // fs.readdirSync/fs.promises.readdir(path, { withFileTypes: true }) —
+    // the Dirent forms, routed BEFORE the 1-arg table completion. The
+    // options must be an object literal with withFileTypes: true (encoding
+    // "utf8"/"utf-8" is accepted as the default it is; recursive and
+    // encoding:'buffer' fence), and the call site's mapped type must carry
+    // the interned Dirent record array (type-mapper.ts) — the userInfo
+    // verification stance.
+    const syncReaddirTypes = bi.module === "fs" && bi.member === "readdirSync";
+    const promiseReaddirTypes = bi.module === "fs/promises" && bi.member === "readdir";
+    if ((syncReaddirTypes || promiseReaddirTypes) && expr.arguments.length === 2) {
+        return lowerFsReaddirTypesCall(lowerer, expr, loc, promiseReaddirTypes);
     }
     if (bi.module === "os" && bi.member === "userInfo") {
         return lowerOsUserInfoCall(lowerer, expr, loc);
@@ -1717,14 +2074,6 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
         }
         return finishWrite(optionValues);
     }
-    // zlib takes Buffers; a string argument (the lib admits it) gets the
-    // wrap-it-first hint instead of a generic type mismatch.
-    if (bi.module === "zlib" && expr.arguments.length >= 1) {
-        const dataIr = lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[0]));
-        if (!(dataIr?.kind === "bytes" && dataIr.elem === "u8")) {
-            lowerer.noLowering(`${bi.member} of '${dataIr ? lowerer.fmt(dataIr) : lowerer.checker.typeToString(lowerer.typeOf(expr.arguments[0]))}' data`, expr.arguments[0], `zlib works on Buffers: ${bi.member}(Buffer.from(s, "utf8"))`);
-        }
-    }
     if (fn.variadicPack) {
         // join(...parts) forwards the array itself; mixing spread and plain
         // arguments (or spreading anything but a string[]) stays out.
@@ -1784,12 +2133,21 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
         }
     }
     const required = fn.params.length - (fn.defaults?.length ?? 0);
-    if (expr.arguments.length < required || expr.arguments.length > fn.params.length) {
+    const hasSpread = expr.arguments.some(ts.isSpreadElement);
+    if (hasSpread && bi.module === "url" && bi.member === "fileURLToPath") {
+        lowerer.noLowering("fileURLToPath with spread arguments", expr, "call fileURLToPath(value) directly so the URL-or-string overload remains statically visible");
+    }
+    if (hasSpread &&
+        ((bi.module === "fs" && bi.member === "readFileSync") ||
+            (bi.module === "fs/promises" && bi.member === "readFile"))) {
+        lowerer.noLowering(`${bi.member} with spread arguments`, expr, `call ${bi.member}(path, "utf8") directly so the required literal encoding remains statically visible`);
+    }
+    if (!hasSpread && (expr.arguments.length < required || expr.arguments.length > fn.params.length)) {
         lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr, bi.member === "readFileSync" || bi.member === "readFile"
             ? `pass the encoding: ${bi.member}(path, "utf8") — Buffer reads and options objects have no lowering`
             : `the supported form takes ${fn.params.length} argument${fn.params.length === 1 ? "" : "s"} (no options objects)`);
     }
-    if (bi.module === "url" && bi.member === "fileURLToPath") {
+    if (!hasSpread && bi.module === "url" && bi.member === "fileURLToPath") {
         // Node accepts a URL value or a URL string — one libFn per receiver
         // form, picked by the argument's static type. Unions (URL |
         // undefined, ...) must narrow first, like everywhere else.
@@ -1803,8 +2161,8 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
         }
         lowerer.noLowering(`fileURLToPath of '${lowerer.fmt(arg.type)}' values`, argNode, "pass a URL value or a URL string (narrow unions first)");
     }
-    if ((bi.module === "fs" && bi.member === "readFileSync") ||
-        (bi.module === "fs/promises" && bi.member === "readFile")) {
+    if (!hasSpread && ((bi.module === "fs" && bi.member === "readFileSync") ||
+        (bi.module === "fs/promises" && bi.member === "readFile"))) {
         // The runtime reads utf8 unconditionally; any other encoding would
         // silently decode wrong, so the ARGUMENT'S TYPE must be the literal
         // "utf8" — or Node's "utf-8" alias, the same decoder (the fallback
@@ -1815,10 +2173,48 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
             lowerer.noLowering(`${bi.member} with a non-"utf8" encoding`, expr.arguments[1], `only utf8 reads are supported: ${bi.member}(path, "utf8")`);
         }
     }
-    const args = expr.arguments.map((a, i) => lowerer.lowerExprExpecting(a, fn.params[i]));
-    for (let i = args.length; i < fn.params.length; i++) {
-        const dflt = fn.defaults[i - required];
-        args.push({ kind: "strLit", value: dflt, type: STRING, loc });
+    // A value-enabled builtin with defaults uses its generated adapter for
+    // direct calls too. That keeps explicit undefined identical to omission:
+    // completeArgs wraps the undefined arm, then the adapter selects the
+    // descriptor's default before entering the fixed runtime libCall ABI.
+    // The call has already passed this member's ordinary arity/shape gates.
+    if (fn.defaults && fn.valueParams) {
+        const callee = lowerer.lowerBuiltinCallableValue(bi, loc);
+        if (!callee || callee.type.kind !== "func") {
+            throw new InternalCompilerError(`missing callable adapter for ${bi.module}.${bi.member}`);
+        }
+        const funcType = callee.type;
+        const shapes = fn.valueParams.map((param, index) => {
+            const type = funcType.params[index];
+            if (!type)
+                throw new InternalCompilerError(`missing callable parameter ${index} for ${bi.module}.${bi.member}`);
+            return { type, mode: param.mode === "optional" ? "omittable" : "required" };
+        });
+        const args = lowerer.completeArgs(expr.arguments, shapes, loc, expr);
+        return { kind: "callValue", callee, args, type: callee.type.ret, loc };
+    }
+    let args;
+    if (hasSpread) {
+        const shapes = fn.params.map((type, i) => i < required
+            ? { type, mode: "required" }
+            : {
+                type,
+                mode: "omittable",
+                callDefault: {
+                    kind: "strLit",
+                    value: fn.defaults[i - required],
+                    type: STRING,
+                    loc,
+                },
+            });
+        args = lowerer.completeArgs(expr.arguments, shapes, loc, expr);
+    }
+    else {
+        args = expr.arguments.map((a, i) => lowerer.lowerExprExpecting(a, fn.params[i]));
+        for (let i = args.length; i < fn.params.length; i++) {
+            const dflt = fn.defaults[i - required];
+            args.push({ kind: "strLit", value: dflt, type: STRING, loc });
+        }
     }
     return { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
 }
@@ -2063,7 +2459,7 @@ export function lowerSpawnCall(lowerer, expr, loc) {
             optsNode = second;
     }
     if (optsNode !== undefined && !ts.isObjectLiteralExpression(optsNode)) {
-        lowerer.noLowering("spawn with a non-literal options argument", optsNode, "pass stdio, detached, env, cwd, and windowsHide in an inline object literal");
+        lowerer.noLowering("spawn with a non-literal options argument", optsNode, "pass stdio, detached, env, cwd, windowsHide, and shell in an inline object literal");
     }
     const emptyStr = { kind: "strLit", value: "", type: STRING, loc };
     // Per-slot stdio modes (scr_child.c: 0 ignore, 1 inherit, 2 fd) and
@@ -2074,6 +2470,8 @@ export function lowerSpawnCall(lowerer, expr, loc) {
     let outFd = numLit(0, loc);
     let errFd = numLit(0, loc);
     let detached = boolLit(false, loc);
+    let shell = boolLit(false, loc);
+    let shellEnabled = false;
     let hasEnv = boolLit(false, loc);
     let envPairs = { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc };
     let cwd = emptyStr;
@@ -2194,8 +2592,21 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                 case "windowsHide":
                     lowerer.lowerExpr(m.value); // Node no-op on POSIX
                     break;
+                case "shell":
+                    if (m.value.kind === ts.SyntaxKind.TrueKeyword) {
+                        shell = boolLit(true, loc);
+                        shellEnabled = true;
+                        plain = false;
+                    }
+                    else if (m.value.kind === ts.SyntaxKind.FalseKeyword) {
+                        shell = boolLit(false, loc);
+                    }
+                    else {
+                        lowerer.noLowering("spawn with a non-literal shell option", m.value, "shell must be a boolean literal");
+                    }
+                    break;
                 default:
-                    lowerer.noLowering(`spawn option '${m.name}'`, p, "stdio, detached, env, cwd, and windowsHide are the supported options");
+                    lowerer.noLowering(`spawn option '${m.name}'`, p, "stdio, detached, env, cwd, windowsHide, and shell are the supported options");
             }
         }
     }
@@ -2203,6 +2614,12 @@ export function lowerSpawnCall(lowerer, expr, loc) {
         inMode = outMode = errMode = 3;
         plain = false;
     }
+    if (shellEnabled && argsNode !== undefined) {
+        const shellArgs = stripTypeCasts(argsNode);
+        if (!ts.isArrayLiteralExpression(shellArgs) || shellArgs.elements.length !== 0) {
+            lowerer.noLowering("spawn with shell enabled and separate arguments", argsNode, "put the complete shell command in the first argument and pass [] (Node deprecates unescaped shell argument concatenation)");
+        }
+    }
     const argv = lowerer.lowerChildArgsArg(argsNode, loc);
     if (plain) {
         return { kind: "libCall", fn: "cp.spawn", args: [cmd, argv], type: CHILD_T, loc };
@@ -2210,11 +2627,213 @@ export function lowerSpawnCall(lowerer, expr, loc) {
     return {
         kind: "libCall",
         fn: "cp.spawnOpts",
-        args: [cmd, argv, numLit(inMode, loc), numLit(outMode, loc), numLit(errMode, loc), outFd, errFd, detached, hasEnv, envPairs, cwd],
+        args: [cmd, argv, numLit(inMode, loc), numLit(outMode, loc), numLit(errMode, loc), outFd, errFd, detached, shell, hasEnv, envPairs, cwd],
+        type: CHILD_T,
+        loc,
+    };
+}
+/** `fork(staticModulePath, args?, options?)` embeds the selected program
+ * module and re-executes the native artifact with one private target id.
+ * Node's default JSON IPC channel is always present. */
+export function lowerForkCall(lowerer, expr, loc) {
+    if (expr.arguments.length < 1 || expr.arguments.length > 3 || expr.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering("fork with this argument shape", expr, "use fork(staticModulePath[, stringArgs][, inlineOptions])");
+    }
+    const targetPath = staticForkModulePath(lowerer.program, expr.arguments[0]);
+    const targetId = targetPath === null
+        ? undefined
+        : lowerer.forkTargetIdByPath.get(tsgoPath(resolve(targetPath)));
+    if (targetId === undefined) {
+        lowerer.noLowering("fork with a runtime-valued module path", expr.arguments[0], 'resolve a relative worker with new URL("./worker.ts", import.meta.url) or fileURLToPath(...) and bind it to a const if needed');
+    }
+    let argsNode;
+    let optsNode;
+    if (expr.arguments.length === 3) {
+        argsNode = expr.arguments[1];
+        optsNode = expr.arguments[2];
+    }
+    else if (expr.arguments.length === 2) {
+        const second = expr.arguments[1];
+        const secondType = lowerer.typeOf(second);
+        const mapped = lowerer.mapTypeOf(secondType);
+        if (lowerer.checker.isArrayType(secondType) ||
+            lowerer.checker.isTupleType(secondType) ||
+            (mapped?.kind === "array" && mapped.elem.kind === "string")) {
+            argsNode = second;
+        }
+        else {
+            optsNode = second;
+        }
+    }
+    if (optsNode !== undefined && !ts.isObjectLiteralExpression(optsNode)) {
+        lowerer.noLowering("fork with a non-literal options argument", optsNode, "pass cwd, env, execArgv, silent, stdio, serialization, and windowsHide in an inline object literal");
+    }
+    let inMode = 1;
+    let outMode = 1;
+    let errMode = 1;
+    let sawStdio = false;
+    let silent = false;
+    let hasEnv = boolLit(false, loc);
+    let envPairs = { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc };
+    let cwd = { kind: "strLit", value: "", type: STRING, loc };
+    const stdioMode = (node, label) => {
+        const type = lowerer.typeOf(node);
+        const value = type.isStringLiteralType() ? type.value : null;
+        if (value !== "ignore" && value !== "inherit" && value !== "pipe") {
+            lowerer.noLowering(`fork with ${label} stdio`, node, '"ignore", "inherit", and "pipe" are the supported stdio modes');
+        }
+        return value === "ignore" ? 0 : value === "inherit" ? 1 : 3;
+    };
+    if (optsNode && ts.isObjectLiteralExpression(optsNode)) {
+        for (const property of optsNode.properties) {
+            const member = optionMember(property);
+            if (!member) {
+                lowerer.noLowering("fork with this options shape", property, "spreads and computed keys have no lowering — write each member inline");
+            }
+            switch (member.name) {
+                case "cwd":
+                    cwd = lowerer.lowerExprExpecting(member.value, STRING);
+                    break;
+                case "env":
+                    hasEnv = boolLit(true, loc);
+                    envPairs = lowerer.recordToEnvPairs(member.value);
+                    break;
+                case "silent":
+                    if (member.value.kind === ts.SyntaxKind.TrueKeyword)
+                        silent = true;
+                    else if (member.value.kind !== ts.SyntaxKind.FalseKeyword) {
+                        lowerer.noLowering("fork with a non-literal silent option", member.value, "silent must be a boolean literal");
+                    }
+                    break;
+                case "stdio": {
+                    if (ts.isArrayLiteralExpression(member.value)) {
+                        if (member.value.elements.length !== 4) {
+                            lowerer.noLowering("fork with this stdio tuple", member.value, 'use [stdin, stdout, stderr, "ipc"] with exactly four literal entries');
+                        }
+                        const ipc = member.value.elements[3];
+                        const ipcType = lowerer.typeOf(ipc);
+                        if (!ipcType.isStringLiteralType() || ipcType.value !== "ipc") {
+                            lowerer.noLowering("fork without a fourth-slot IPC channel", ipc, 'the fourth stdio entry must be "ipc"');
+                        }
+                        inMode = stdioMode(member.value.elements[0], "stdin");
+                        outMode = stdioMode(member.value.elements[1], "stdout");
+                        errMode = stdioMode(member.value.elements[2], "stderr");
+                    }
+                    else {
+                        const mode = stdioMode(member.value, "scalar");
+                        inMode = outMode = errMode = mode;
+                    }
+                    sawStdio = true;
+                    break;
+                }
+                case "serialization": {
+                    const type = lowerer.typeOf(member.value);
+                    if (!type.isStringLiteralType() || type.value !== "json") {
+                        lowerer.noLowering("fork with non-JSON serialization", member.value, 'the static IPC channel supports Node\'s default serialization or serialization: "json"');
+                    }
+                    break;
+                }
+                case "execArgv":
+                    // Loader flags configure the Node executable. The native worker is
+                    // already compiled into this artifact, so no loader starts.
+                    break;
+                case "windowsHide":
+                    lowerer.lowerExpr(member.value); // accepted platform presentation option
+                    break;
+                default:
+                    lowerer.noLowering(`fork with the '${member.name}' option`, member.value, "cwd, env, execArgv, silent, stdio, serialization, and windowsHide are supported");
+            }
+        }
+    }
+    if (!sawStdio && silent)
+        inMode = outMode = errMode = 3;
+    return {
+        kind: "libCall",
+        fn: "cp.fork",
+        args: [
+            numLit(targetId, loc),
+            lowerChildArgsArg(lowerer, argsNode, loc),
+            numLit(inMode, loc),
+            numLit(outMode, loc),
+            numLit(errMode, loc),
+            hasEnv,
+            envPairs,
+            cwd,
+        ],
         type: CHILD_T,
         loc,
     };
 }
+/** `execFile(file[, args][, options], callback)` — the asynchronous callback
+ * slice. The child starts immediately with stdin/stdout/stderr piped; the
+ * runtime captures both outputs and invokes the error-first callback after
+ * settlement. The callback may ignore a suffix of `(error, stdout,
+ * stderr)`, but every declared parameter must have the Node shape. Inline
+ * `encoding: "utf8"` and a pure numeric `maxBuffer` are accepted; the latter
+ * is not enforced by the growing native capture, as
+ * with the synchronous and promisified capture forms. Other options remain
+ * fenced until their lifecycle can share this asynchronous core. */
+export function lowerExecFileCall(lowerer, expr, loc) {
+    if (expr.arguments.some(ts.isSpreadElement) || expr.arguments.length < 2 || expr.arguments.length > 4) {
+        lowerer.noLowering(`execFile with ${expr.arguments.length} arguments`, expr, "the supported callback forms are execFile(file, callback), execFile(file, args, callback), and execFile(file, args, { encoding: 'utf8', maxBuffer: N }, callback)");
+    }
+    const cmd = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+    const argsNode = expr.arguments.length >= 3 ? expr.arguments[1] : undefined;
+    const callbackNode = expr.arguments[expr.arguments.length - 1];
+    const argv = lowerer.lowerChildArgsArg(argsNode, loc);
+    if (expr.arguments.length === 4) {
+        const options = expr.arguments[2];
+        if (!ts.isObjectLiteralExpression(options)) {
+            lowerer.noLowering("execFile with a non-literal options argument", options, "pass encoding and maxBuffer in an inline object literal");
+        }
+        const pureNumber = (node) => ts.isNumericLiteral(node) ||
+            (ts.isParenthesizedExpression(node) && pureNumber(node.expression)) ||
+            (ts.isBinaryExpression(node) &&
+                [ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken, ts.SyntaxKind.AsteriskToken, ts.SyntaxKind.SlashToken].includes(node.operatorToken.kind) &&
+                pureNumber(node.left) && pureNumber(node.right));
+        for (const property of options.properties) {
+            const member = optionMember(property);
+            if (!member)
+                lowerer.noLowering("execFile with this options shape", property, "use plain encoding and maxBuffer properties without spreads or computed keys");
+            if (member.name === "encoding") {
+                if (!ts.isStringLiteral(member.value) || (member.value.text !== "utf8" && member.value.text !== "utf-8")) {
+                    lowerer.noLowering("execFile with a non-literal utf8 encoding", member.value, "pass the literal 'utf8' or 'utf-8' (other expressions might have side effects)");
+                }
+            }
+            else if (member.name === "maxBuffer") {
+                if (!pureNumber(member.value)) {
+                    lowerer.noLowering("execFile with a non-literal maxBuffer", member.value, "pass a numeric literal or literal arithmetic (the native capture grows without enforcing this limit)");
+                }
+            }
+            else {
+                lowerer.noLowering(`execFile option '${member.name}'`, property, "only encoding: 'utf8' and a pure numeric maxBuffer are supported in the callback form");
+            }
+        }
+    }
+    const callback = lowerer.lowerExpr(callbackNode);
+    if (callback.type.kind !== "func" || callback.type.rest === true || callback.type.params.length > 3) {
+        lowerer.unsupported("SC1090", callbackNode, "execFile callbacks take (error), (error, stdout), (error, stdout, stderr), or no parameters");
+    }
+    if (callback.type.ret.kind !== "void") {
+        lowerer.unsupported("SC1090", callbackNode, "execFile callbacks returning a value (make the callback body a block, or return nothing)");
+    }
+    const errorParam = callback.type.params[0];
+    if (errorParam !== undefined) {
+        const def = errorParam.kind === "union" ? lowerer.unions.get(errorParam.unionId) : undefined;
+        const valid = !!def && def.arms.length === 2 &&
+            def.arms.some((arm) => arm.kind === "nullT") &&
+            def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error");
+        if (!valid) {
+            lowerer.unsupported("SC1090", callbackNode, `execFile callbacks whose first parameter is not 'Error | null' (got '${lowerer.fmt(errorParam)}')`);
+        }
+    }
+    for (let i = 1; i < callback.type.params.length; i++) {
+        if (callback.type.params[i].kind !== "string") {
+            lowerer.unsupported("SC1090", callbackNode, `execFile callbacks whose ${i === 1 ? "stdout" : "stderr"} parameter is not 'string'`);
+        }
+    }
+    return { kind: "libCall", fn: "cp.execFile", args: [cmd, argv, callback], type: CHILD_T, loc };
+}
 /** `execFileSync(file, args?, options?)` / `execSync(command, options?)`
    * → the ONE cp.execSync libCall. execSync wraps the command in
    * `/bin/sh -c` (Node's shell semantics — a single command string, no
@@ -2714,13 +3333,10 @@ function execStdioModeHelper(lowerer, shapeId, stdioT, fd, loc) {
     });
     return name;
 }
-/** `const execFileAsync = promisify(execFile)` — the ONE lowered
-   * util.promisify shape. Returns true (and registers the declared symbol
-   * so call sites lower and value uses fence) when `init` is a promisify
-   * call over a child_process.execFile import binding; a promisify call
-   * over anything else fences HERE with the supported-target hint (the
-   * declaration is where the target is visible). False for non-promisify
-   * initializers, so the ordinary declaration paths apply. */
+/** Compile-time util.promisify projections. The immutable result binding
+   * owns no runtime slot: calls rewrite to the target's promise lowering,
+   * while value uses remain explicit fences. Unsupported targets report at
+   * the declaration, where their identity is still visible. */
 export function isPromisifyCall(lowerer, init) {
     let e = init;
     while (ts.isParenthesizedExpression(e))
@@ -2734,7 +3350,38 @@ export function isPromisifyCall(lowerer, init) {
         return null;
     return e;
 }
-export function promisifiedExecFileDecl(lowerer, nameNode, init) {
+/** Immutable aliases of table-backed builtin functions. The alias is a
+ * compile-time call target, so direct calls keep the builtin's validated
+ * lowering without materializing a JavaScript function object. Value
+ * uses remain fenced until an escaping closure adapter exists. */
+export function registerBuiltinCallableAlias(lowerer, nameNode, init) {
+    if (!ts.isIdentifier(nameNode) || !init)
+        return false;
+    let targetExpr = init;
+    while (ts.isParenthesizedExpression(targetExpr))
+        targetExpr = targetExpr.expression;
+    if (!ts.isIdentifier(targetExpr))
+        return false;
+    const sourceSymbol = lowerer.resolveValueSymbol(targetExpr);
+    const existing = sourceSymbol ? lowerer.staticCallables.get(sourceSymbol) : undefined;
+    const target = existing?.kind === "builtin-function"
+        ? { module: existing.module, member: existing.member }
+        : lowerer.builtinImportOf(targetExpr);
+    if (!target || !builtinModuleFnOf(lowerer, target.module, target.member))
+        return false;
+    if (lowerer.checker.getCallSignatures(lowerer.typeOf(nameNode)).length === 0)
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+    if (!symbol)
+        return false;
+    lowerer.staticCallables.set(symbol, {
+        kind: "builtin-function",
+        module: target.module,
+        member: target.member,
+    });
+    return true;
+}
+export function registerPromisifiedBuiltinDecl(lowerer, nameNode, init) {
     if (!init)
         return false;
     // The OTHER special const-binding form this decl hook serves: the
@@ -2748,12 +3395,17 @@ export function promisifiedExecFileDecl(lowerer, nameNode, init) {
         return false;
     const argNode = e.arguments.length === 1 ? e.arguments[0] : null;
     const target = argNode && ts.isIdentifier(argNode) ? lowerer.builtinImportOf(argNode) : null;
-    if (!target || target.module !== "child_process" || target.member !== "execFile") {
-        lowerer.noLowering("util.promisify of this target", argNode ?? e, "child_process.execFile is the one promisifiable target: const execFileAsync = promisify(execFile)");
+    const projection = target?.module === "child_process" && target.member === "execFile"
+        ? { kind: "promisified-exec-file" }
+        : target?.module === "fs" && target.member === "readFile"
+            ? { kind: "promisified-builtin", module: "fs/promises", member: "readFile" }
+            : null;
+    if (!projection) {
+        lowerer.noLowering("util.promisify of this target", argNode ?? e, "child_process.execFile and fs.readFile are the supported targets");
     }
     const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
     if (symbol)
-        lowerer.promisifiedExecFile.add(symbol);
+        lowerer.staticCallables.set(symbol, projection);
     return true;
 }
 /** A call THROUGH a promisified-execFile binding:
@@ -3862,18 +4514,18 @@ function cryptoInputBytes(lowerer, node, loc) {
     }
     lowerer.noLowering(`crypto byte input of '${lowerer.fmt(value.type)}' values`, node, "string and Buffer/Uint8Array values are supported");
 }
-function cryptoBytesCallback(lowerer, node) {
+function errorFirstBytesCallback(lowerer, node, api) {
     let callback = lowerer.lowerExpr(node);
     if (callback.type.kind === "dyn") {
         callback = { kind: "dynCheck", value: callback, type: funcOf([DYN, DYN], VOID), loc: locOf(node) };
     }
     if (callback.type.kind !== "func" || callback.type.params.length > 2) {
-        lowerer.unsupported("SC1090", node, "crypto callbacks must accept at most (error, buffer)");
+        lowerer.unsupported("SC1090", node, `${api} callbacks must accept at most (error, buffer)`);
     }
     const error = callback.type.params[0];
     if (error !== undefined && error.kind !== "dyn") {
         if (error.kind !== "union") {
-            lowerer.unsupported("SC1090", node, "crypto callback error parameters must be Error | null");
+            lowerer.unsupported("SC1090", node, `${api} callback error parameters must be Error | null`);
         }
         const def = lowerer.unions.get(error.unionId);
         const valid = !!def &&
@@ -3881,11 +4533,11 @@ function cryptoBytesCallback(lowerer, node) {
             def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error") &&
             def.arms.every((arm) => arm.kind === "nullT" || arm.kind === "undefinedT" || (arm.kind === "object" && arm.className === "%Error"));
         if (!valid)
-            lowerer.unsupported("SC1090", node, "crypto callback error parameters must be Error | null");
+            lowerer.unsupported("SC1090", node, `${api} callback error parameters must be Error | null`);
     }
     const value = callback.type.params[1];
     if (value !== undefined && value.kind !== "dyn" && !(value.kind === "bytes" && value.elem === "u8")) {
-        lowerer.unsupported("SC1090", node, "crypto callback result parameters must be Buffer/Uint8Array values");
+        lowerer.unsupported("SC1090", node, `${api} callback result parameters must be Buffer/Uint8Array values`);
     }
     return voidizedCallback(lowerer, callback, locOf(node));
 }
@@ -3909,7 +4561,7 @@ export function lowerCryptoModuleCall(lowerer, expr, bi, loc) {
         return {
             kind: "libCall",
             fn: "crypto.randomBytesCb",
-            args: [lowerer.lowerExprExpecting(args[0], F64), cryptoBytesCallback(lowerer, args[1])],
+            args: [lowerer.lowerExprExpecting(args[0], F64), errorFirstBytesCallback(lowerer, args[1], "crypto")],
             type: VOID,
             loc,
         };
@@ -3927,7 +4579,7 @@ export function lowerCryptoModuleCall(lowerer, expr, bi, loc) {
                 lowerer.lowerExprExpecting(args[2], F64),
                 lowerer.lowerExprExpecting(args[3], F64),
                 cryptoAlgorithm(lowerer, args[4], "crypto.pbkdf2"),
-                cryptoBytesCallback(lowerer, args[5]),
+                errorFirstBytesCallback(lowerer, args[5], "crypto"),
             ],
             type: VOID,
             loc,
@@ -4055,7 +4707,7 @@ export function lowerUrlMethodCall(lowerer, call, access) {
         const receiver = lowerer.lowerExpr(access.expression);
         return { kind: "libCall", fn: "url.href", args: [receiver], type: STRING, loc: locOf(call) };
     }
-    lowerer.noLowering(`URL.${name}`, call, "protocol, pathname, href, and toString() are the supported URL members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`URL.${name}`, call, "protocol, origin, username, password, pathname, href, host, hostname, port, search, hash, searchParams, and toString() are the supported URL members", lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** `new URLSearchParams(init?)` — the WHATWG constructor's lowered init
    * shapes: omitted / literal `undefined` (empty list), a string (parsed,
@@ -4637,7 +5289,7 @@ export function lowerStatsMethodCall(lowerer, call, access) {
                 : "stats.isSymbolicLink";
         return { kind: "libCall", fn, args: [receiver], type: BOOL, loc: locOf(call) };
     }
-    lowerer.noLowering(`Stats.${name}`, call, "isFile(), isDirectory(), isSymbolicLink(), size, blocks, nlink, atimeMs, and mtimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`Stats.${name}`, call, "isFile(), isDirectory(), isSymbolicLink(), dev, ino, size, blocks, nlink, atimeMs, mtimeMs, and ctimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** Calls on native crypto.Hash/Hmac handles. The handle survives locals,
    * aliases, loops, and returns; update() retains and returns the receiver,
@@ -4810,6 +5462,15 @@ export function lowerBuiltinExtraProperty(lowerer, expr) {
         };
         return lowerer.maybeNarrow(read, expr);
     }
+    if (kind === "child" && name === "connected") {
+        return {
+            kind: "libCall",
+            fn: "child.connected",
+            args: [lowerer.lowerExpr(expr.expression)],
+            type: BOOL,
+            loc,
+        };
+    }
     if (kind === "child")
         return null; // pid/exitCode/killed live in lowerIntrinsicProperty
     if (kind === "childWriter") {
@@ -4823,7 +5484,8 @@ export function lowerBuiltinExtraProperty(lowerer, expr) {
         lowerer.noLowering(`Writable.${name}`, expr, 'write(string | Uint8Array), end(), destroy(), writable, and on/once("drain" | "finish" | "error", cb) are supported', lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "stats" &&
-        (name === "blocks" || name === "nlink" || name === "atimeMs" || name === "mtimeMs")) {
+        (name === "dev" || name === "ino" || name === "blocks" || name === "nlink" ||
+            name === "atimeMs" || name === "mtimeMs" || name === "ctimeMs")) {
         const receiver = lowerer.lowerExpr(expr.expression);
         const fn = `stats.${name}`;
         return { kind: "libCall", fn, args: [receiver], type: F64, loc };
@@ -4850,6 +5512,63 @@ export function lowerBuiltinExtraProperty(lowerer, expr) {
    * lowerIntrinsicProperty). Everything else @types/node declares on
    * ChildProcess (stdout, once, ...) fences member-qualified. Null for
    * non-child receivers. */
+function ignoredListenerReturn(type) {
+    return type.kind === "void" || (type.kind === "promise" && type.inner.kind === "void");
+}
+function ipcJsonMessage(lowerer, node, loc) {
+    const value = lowerer.lowerExpr(node);
+    if (!lowerer.jsonStringifySafe(value.type) && value.type.kind !== "dyn") {
+        lowerer.unsupported("SC1090", node, `IPC messages of '${lowerer.fmt(value.type)}' values (messages must be JSON-stringifiable records, arrays, primitives, unions of those, or unknown)`);
+    }
+    return { kind: "jsonStringify", value, type: STRING, loc };
+}
+function ipcMessageListener(lowerer, node) {
+    const cb = lowerer.lowerExpr(node);
+    if (cb.type.kind !== "func" || cb.type.params.length > 1 || !ignoredListenerReturn(cb.type.ret)) {
+        lowerer.unsupported("SC1090", node, "message listeners take zero or one parameter and may return void or Promise<void>");
+    }
+    const param = cb.type.params[0];
+    if (param !== undefined && param.kind !== "dyn" && !lowerer.jsonSafe(param)) {
+        lowerer.unsupported("SC1090", node, `message listeners whose parameter is not JSON-shaped or unknown (got '${lowerer.fmt(param)}')`);
+    }
+    return cb;
+}
+function ipcDisconnectListener(lowerer, node) {
+    const cb = lowerer.lowerExpr(node);
+    if (cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void") {
+        lowerer.unsupported("SC1090", node, "disconnect listeners take no parameters and return void");
+    }
+    return cb;
+}
+function ipcSendCallback(lowerer, node) {
+    const cb = lowerer.lowerExpr(node);
+    if (cb.type.kind !== "func" || cb.type.params.length > 1 || cb.type.ret.kind !== "void") {
+        lowerer.unsupported("SC1090", node, "send callbacks take () or (error: Error | null) and return void");
+    }
+    const param = cb.type.params[0];
+    if (param !== undefined) {
+        const def = param.kind === "union" ? lowerer.unions.get(param.unionId) : undefined;
+        const valid = !!def && def.arms.length === 2 &&
+            def.arms.some((arm) => arm.kind === "nullT") &&
+            def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error");
+        if (!valid) {
+            lowerer.unsupported("SC1090", node, `send callbacks whose parameter is not 'Error | null' (got '${lowerer.fmt(param)}')`);
+        }
+    }
+    return cb;
+}
+function lowerProcessIpcSend(lowerer, call) {
+    const loc = locOf(call);
+    if (call.arguments.length < 1 || call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`process.send with ${call.arguments.length} arguments`, call, "send(message[, callback]) is supported; handle transfer and options are not");
+    }
+    const json = ipcJsonMessage(lowerer, call.arguments[0], loc);
+    if (call.arguments[1] === undefined) {
+        return { kind: "libCall", fn: "process.send", args: [json], type: BOOL, loc };
+    }
+    const callback = ipcSendCallback(lowerer, call.arguments[1]);
+    return { kind: "libCall", fn: "process.sendCb", args: [json, callback], type: BOOL, loc };
+}
 export function lowerChildMethodCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
@@ -4859,20 +5578,63 @@ export function lowerChildMethodCall(lowerer, call, access) {
         return null;
     const name = access.name.text;
     const loc = locOf(call);
-    if (name === "on" && call.arguments.length === 2) {
+    if (name === "send") {
+        if (call.arguments.length < 1 || call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`child.send with ${call.arguments.length} arguments`, call, "send(message[, callback]) is supported; handle transfer and options are not");
+        }
+        const receiver = lowerer.lowerExpr(access.expression);
+        const json = ipcJsonMessage(lowerer, call.arguments[0], loc);
+        if (call.arguments[1] === undefined) {
+            return { kind: "libCall", fn: "child.send", args: [receiver, json], type: BOOL, loc };
+        }
+        const callback = ipcSendCallback(lowerer, call.arguments[1]);
+        return { kind: "libCall", fn: "child.sendCb", args: [receiver, json, callback], type: BOOL, loc };
+    }
+    if (name === "disconnect" && call.arguments.length === 0) {
+        if (!ts.isExpressionStatement(call.parent)) {
+            lowerer.unsupported("SC1090", call, "using the result of child.disconnect() (call it as its own statement)");
+        }
+        return {
+            kind: "libCall",
+            fn: "child.disconnect",
+            args: [lowerer.lowerExpr(access.expression)],
+            type: VOID,
+            loc,
+        };
+    }
+    if ((name === "on" || name === "once") && call.arguments.length === 2) {
         const evT = lowerer.typeOf(call.arguments[0]);
         const event = evT.isStringLiteralType() ? evT.value : null;
-        if (event !== "exit" && event !== "error") {
-            lowerer.noLowering(`child.on(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"exit" and "error" are the supported child events (as literals)');
+        if (event !== "exit" && event !== "close" && event !== "error" && event !== "message" && event !== "disconnect") {
+            lowerer.noLowering(`child.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"exit", "close", "error", "message", and "disconnect" are the supported child events (as literals)');
         }
         if (!ts.isExpressionStatement(call.parent)) {
-            lowerer.unsupported("SC1090", call, "chaining child.on(...) (the result is void here — register each listener as its own statement)");
+            lowerer.unsupported("SC1090", call, `chaining child.${name}(...) (the result is void here — register each listener as its own statement)`);
         }
         const receiver = lowerer.lowerExpr(access.expression);
+        const once = { kind: "boolLit", value: name === "once", type: BOOL, loc };
+        if (event === "message") {
+            return {
+                kind: "libCall",
+                fn: "child.onMessage",
+                args: [receiver, ipcMessageListener(lowerer, call.arguments[1]), once],
+                type: VOID,
+                loc,
+            };
+        }
+        if (event === "disconnect") {
+            return {
+                kind: "libCall",
+                fn: "child.onDisconnect",
+                args: [receiver, ipcDisconnectListener(lowerer, call.arguments[1]), once],
+                type: VOID,
+                loc,
+            };
+        }
         const cb = lowerer.lowerExpr(call.arguments[1]);
-        if (cb.type.kind !== "func" || cb.type.params.length > (event === "exit" ? 2 : 1)) {
-            lowerer.unsupported("SC1090", call.arguments[1], event === "exit"
-                ? "exit listeners with more than two parameters (use (code, signal), (code), or ())"
+        if (cb.type.kind !== "func" || cb.type.params.length > (event === "error" ? 1 : 2)) {
+            lowerer.unsupported("SC1090", call.arguments[1], event !== "error"
+                ? `${event} listeners with more than two parameters (use (code, signal), (code), or ())`
                 : "error listeners with more than one parameter (use (err) or ())");
         }
         if (cb.type.ret.kind !== "void") {
@@ -4882,7 +5644,7 @@ export function lowerChildMethodCall(lowerer, call, access) {
             lowerer.unsupported("SC1090", call.arguments[1], "listeners returning a value (make the callback body a block, or return nothing)");
         }
         const param = cb.type.params[0];
-        if (event === "exit") {
+        if (event === "exit" || event === "close") {
             const armsOk = param === undefined ||
                 (param.kind === "union" &&
                     (() => {
@@ -4892,7 +5654,7 @@ export function lowerChildMethodCall(lowerer, call, access) {
                             def.arms[1].kind === "nullT");
                     })());
             if (!armsOk) {
-                lowerer.unsupported("SC1090", call.arguments[1], `exit listeners whose parameter is not 'number | null' (got '${lowerer.fmt(param)}')`);
+                lowerer.unsupported("SC1090", call.arguments[1], `${event} listeners whose parameter is not 'number | null' (got '${lowerer.fmt(param)}')`);
             }
             // The optional SECOND parameter is Node's signal: the terminating
             // signal's name as `Signals | null` — a string | null union here
@@ -4907,9 +5669,9 @@ export function lowerChildMethodCall(lowerer, call, access) {
                             def.arms.some((a) => a.kind === "nullT"));
                     })());
             if (!sigOk) {
-                lowerer.unsupported("SC1090", call.arguments[1], `exit listeners whose signal parameter is not 'Signals | null' (got '${lowerer.fmt(sigParam)}')`);
+                lowerer.unsupported("SC1090", call.arguments[1], `${event} listeners whose signal parameter is not 'Signals | null' (got '${lowerer.fmt(sigParam)}')`);
             }
-            return { kind: "libCall", fn: "child.onExit", args: [receiver, cb], type: VOID, loc };
+            return { kind: "libCall", fn: event === "close" ? "child.onClose" : "child.onExit", args: [receiver, cb], type: VOID, loc };
         }
         if (param !== undefined && !(param.kind === "object" && param.className === "%Error")) {
             lowerer.unsupported("SC1090", call.arguments[1], `error listeners whose parameter is not 'Error' (got '${lowerer.fmt(param)}')`);
@@ -4948,7 +5710,7 @@ export function lowerChildMethodCall(lowerer, call, access) {
         const receiver = lowerer.lowerExpr(access.expression);
         return { kind: "libCall", fn: "child.unref", args: [receiver], type: VOID, loc };
     }
-    lowerer.noLowering(`ChildProcess.${name}`, call, "on(\"exit\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are the supported ChildProcess members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`ChildProcess.${name}`, call, "send(), connected, disconnect(), on/once(\"message\" | \"disconnect\" | \"exit\" | \"close\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are supported", lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** Method calls on piped child-output stream receivers (child.stdout /
    * child.stderr — the childStream kind): on/once("data" | "end").
@@ -4970,6 +5732,11 @@ export function lowerChildStreamMethodCall(lowerer, call, access) {
         return null;
     const name = access.name.text;
     const loc = locOf(call);
+    if (name === "setEncoding" && call.arguments.length === 1) {
+        const receiver = lowerer.lowerExprExpecting(access.expression, CHILDSTREAM_T);
+        const enc = bufEncoding(lowerer, "child stream setEncoding", call.arguments[0]);
+        return { kind: "libCall", fn: "stream.childSetEncoding", args: [receiver, strLit(enc, loc)], type: CHILDSTREAM_T, loc };
+    }
     if ((name === "on" || name === "once") && call.arguments.length === 2) {
         const evT = lowerer.typeOf(call.arguments[0]);
         const event = evT.isStringLiteralType() ? evT.value : null;
@@ -4998,12 +5765,12 @@ export function lowerChildStreamMethodCall(lowerer, call, access) {
             const def = lowerer.unions.get(p.unionId);
             return !!def && def.arms.some((a) => a.kind === "bytes" && a.elem === "u8");
         };
-        if (param !== undefined && !(param.kind === "bytes" && param.elem === "u8") && !unionOk(param)) {
-            lowerer.unsupported("SC1090", call.arguments[1], `data listeners whose parameter is not 'Buffer' (or a Buffer-armed union; got '${lowerer.fmt(param)}')`);
+        if (param !== undefined && param.kind !== "string" && !(param.kind === "bytes" && param.elem === "u8") && !unionOk(param)) {
+            lowerer.unsupported("SC1090", call.arguments[1], `data listeners whose parameter is not 'Buffer', 'string', or a Buffer-armed union (got '${lowerer.fmt(param)}')`);
         }
-        return { kind: "libCall", fn: "stream.onData", args: [receiver, cb, once], type: VOID, loc };
+        return { kind: "libCall", fn: param?.kind === "string" ? "stream.onDataStr" : "stream.onData", args: [receiver, cb, once], type: VOID, loc };
     }
-    lowerer.noLowering(`ReadableStream.${name}`, call, 'on/once("data" | "end", cb) are the supported child-stream members', lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`ReadableStream.${name}`, call, 'setEncoding(encoding) and on/once("data" | "end", cb) are the supported child-stream members', lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** Method calls on a piped child stdin writer. Writes copy one string or
  * Uint8Array into the nonblocking runtime queue and return the backpressure
@@ -5290,6 +6057,19 @@ export function lowerProcessStreamProperty(lowerer, expr) {
     let recv = expr.expression;
     while (ts.isParenthesizedExpression(recv) || ts.isAsExpression(recv) || ts.isTypeAssertion(recv))
         recv = recv.expression;
+    // Browser-compatible packages commonly write
+    // `(process.stdout || {}).isTTY`. Node's stream object is always
+    // present and truthy, so the fallback cannot run; match the left
+    // receiver exactly as the value-level always-truthy `||` lowering
+    // does, preserving the native isatty/columns answer.
+    if (ts.isBinaryExpression(recv) &&
+        recv.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+        let left = recv.left;
+        while (ts.isParenthesizedExpression(left) || ts.isAsExpression(left) || ts.isTypeAssertion(left))
+            left = left.expression;
+        if (ts.isPropertyAccessExpression(left))
+            recv = left;
+    }
     if (!ts.isPropertyAccessExpression(recv))
         return null;
     const stream = lowerer.stdlibGlobalMember(recv, "process");
@@ -5399,6 +6179,9 @@ export function lowerProcessProperty(lowerer, expr) {
     if (member === "argv") {
         return { kind: "libCall", fn: "process.argv", args: [], type: arrayOf(STRING), loc };
     }
+    if (member === "connected") {
+        return { kind: "libCall", fn: "process.connected", args: [], type: BOOL, loc };
+    }
     // process.execArgv: the extra CLI arguments Node itself consumed — a
     // compiled binary consumed none, so the honest answer is a fresh [].
     if (member === "execArgv") {
@@ -5477,48 +6260,55 @@ export function envValueType(lowerer) {
    * @types/node, a user alias reshaping the result) fences honestly. Key
    * and row order follow getifaddrs enumeration — Node itself guarantees
    * no order (compare structurally). */
-/** `fs.readdirSync(path, { withFileTypes: true })` — Dirent rows: name +
-   * parentPath (the path argument as given, Node's own rule) + the hidden
-   * %dtype entry kind (libuv's UV_DIRENT encoding; DT_UNKNOWN falls back
-   * to lstat, Node's getDirents rule). The options literal is checked
-   * member-by-member; the result type must be the interned Dirent record
-   * array from type-mapper.ts — anything else (encoding: 'buffer', a user alias
-   * reshaping Dirent) fences honestly. */
-function lowerFsReaddirTypesCall(lowerer, call, loc) {
+/** `fs.readdirSync` / `fs.promises.readdir` with `{ withFileTypes: true }`
+   * — Dirent rows: name + parentPath (the path argument as given, Node's
+   * own rule) + the hidden %dtype entry kind (libuv's UV_DIRENT encoding;
+   * DT_UNKNOWN falls back to lstat, Node's getDirents rule). The options
+   * literal is checked member-by-member; the result type must carry the
+   * interned Dirent record array from type-mapper.ts — anything else
+   * (encoding: 'buffer', a user alias reshaping Dirent) fences honestly. */
+function lowerFsReaddirTypesCall(lowerer, call, loc, promiseForm) {
+    const operation = promiseForm ? "fs.promises.readdir" : "readdirSync";
+    const spelling = promiseForm ? "readdir" : "readdirSync";
     const optsNode = call.arguments[1];
     if (!ts.isObjectLiteralExpression(optsNode)) {
-        lowerer.noLowering("readdirSync with a non-literal options argument", optsNode, "pass the options inline so each member can be checked: readdirSync(path, { withFileTypes: true })");
+        lowerer.noLowering(`${operation} with a non-literal options argument`, optsNode, `pass the options inline so each member can be checked: ${spelling}(path, { withFileTypes: true })`);
     }
     let sawWithFileTypes = false;
     for (const p of optsNode.properties) {
         const m = optionMember(p);
         if (!m) {
-            lowerer.noLowering("readdirSync with this options shape", p, "spreads and computed keys have no lowering — write each member inline");
+            lowerer.noLowering(`${operation} with this options shape`, p, "spreads and computed keys have no lowering — write each member inline");
         }
         if (m.name === "withFileTypes") {
             const t = lowerer.typeOf(m.value);
             if (!(t.flags & ts.TypeFlags.BooleanLiteral) || lowerer.checker.typeToString(t) !== "true") {
-                lowerer.noLowering("readdirSync with a non-literal-true withFileTypes", m.value, "withFileTypes: true is the Dirent form; omit the options for plain names");
+                lowerer.noLowering(`${operation} with a non-literal-true withFileTypes`, m.value, "withFileTypes: true is the Dirent form; omit the options for plain names");
             }
             sawWithFileTypes = true;
         }
         else if (m.name === "encoding") {
             const t = lowerer.typeOf(m.value);
             if (!t.isStringLiteralType() || (t.value !== "utf8" && t.value !== "utf-8")) {
-                lowerer.noLowering("readdirSync with a non-utf8 encoding", m.value, "names decode as utf8 (the default); encoding: 'buffer' has no lowering");
+                lowerer.noLowering(`${operation} with a non-utf8 encoding`, m.value, "names decode as utf8 (the default); encoding: 'buffer' has no lowering");
             }
         }
         else {
             // The options-record stance: recursive (a documented knob with
             // no lowering) fences by name; undocumented keys drop like Node.
-            fenceOrDropOptionKey(lowerer, p, m.name, "readdirSync", FS_READDIR_DOCUMENTED_OPTIONS, "withFileTypes: true (and the default encoding) is the supported options surface — recursive listings want an explicit walk");
+            fenceOrDropOptionKey(lowerer, p, m.name, operation, FS_READDIR_DOCUMENTED_OPTIONS, "withFileTypes: true (and the default encoding) is the supported options surface — recursive listings want an explicit walk");
         }
     }
     if (!sawWithFileTypes) {
-        lowerer.noLowering("readdirSync with 2 arguments", call, "readdirSync(path) lists names; readdirSync(path, { withFileTypes: true }) lists Dirents");
+        lowerer.noLowering(`${operation} with 2 arguments`, call, `${spelling}(path) lists names; ${spelling}(path, { withFileTypes: true }) lists Dirents`);
     }
-    const fence = () => lowerer.noLowering("readdirSync(path, { withFileTypes: true }) where the result is not the Dirent array", call, "{ name, parentPath, isFile(), isDirectory(), isSymbolicLink() } rows are the supported result shape");
-    const result = lowerer.mapTypeOf(lowerer.typeOf(call));
+    const fence = () => lowerer.noLowering(`${operation}(path, { withFileTypes: true }) where the result is not the Dirent array`, call, "{ name, parentPath, isFile(), isDirectory(), isSymbolicLink() } rows are the supported result shape");
+    const callType = lowerer.mapTypeOf(lowerer.typeOf(call));
+    if (!callType)
+        fence();
+    const result = promiseForm
+        ? callType.kind === "promise" ? callType.inner : fence()
+        : callType;
     if (result?.kind !== "array" || result.elem.kind !== "record")
         fence();
     const shape = lowerer.shapes.get(result.elem.shapeId);
@@ -5530,7 +6320,13 @@ function lowerFsReaddirTypesCall(lowerer, call, loc) {
         fence();
     }
     const path = lowerer.lowerExprExpecting(call.arguments[0], STRING);
-    return { kind: "libCall", fn: "fs.readdirTypesSync", args: [path], type: result, loc };
+    return {
+        kind: "libCall",
+        fn: promiseForm ? "fsp.readdirTypes" : "fs.readdirTypesSync",
+        args: [path],
+        type: callType,
+        loc,
+    };
 }
 /** `d.isFile()` / `d.isDirectory()` / `d.isSymbolicLink()` on a Dirent-
    * typed receiver (the interned record — provenance via the checker's
@@ -5864,13 +6660,23 @@ export function lowerProcessEnvGet(lowerer, expr) {
 }
 /** `process.exit(code)` / `process.cwd()` → libCall. The fallback
    * declaration makes exit's code required; @types/node declares it
-   * optional, and a bare `process.exit()` lowers as exit(0) — exactly
-   * Node's behavior when process.exitCode was never set (setting exitCode
-   * is fenced like every other unsupported process member, so "never set"
-   * always holds in a compiled program). */
+   * optional. A bare `process.exit()` uses the current exitCode, or zero
+   * when unset. */
 export function lowerProcessMethodCall(lowerer, call, access) {
     if (call.questionDotToken)
         return null;
+    const directProcessMember = lowerer.stdlibGlobalMember(access, "process");
+    if (directProcessMember === "send")
+        return lowerProcessIpcSend(lowerer, call);
+    if (directProcessMember === "disconnect") {
+        if (call.arguments.length !== 0) {
+            lowerer.noLowering(`process.disconnect with ${call.arguments.length} arguments`, call);
+        }
+        if (!ts.isExpressionStatement(call.parent)) {
+            lowerer.unsupported("SC1090", call, "using the result of process.disconnect() (call it as its own statement)");
+        }
+        return { kind: "libCall", fn: "process.disconnect", args: [], type: VOID, loc: locOf(call) };
+    }
     // process.stdout.write(s[, encoding][, callback]) and stderr's twin:
     // raw bytes, no newline or formatting. stdout shares console.log's
     // promptly-submitted stream, preserving source order. Node's boolean
@@ -6131,6 +6937,21 @@ export function lowerProcessMethodCall(lowerer, call, access) {
         }
         const evT = lowerer.typeOf(call.arguments[0]);
         const event = evT.isStringLiteralType() ? evT.value : null;
+        if ((event === "message" || event === "disconnect") && !isOff) {
+            if (!ts.isExpressionStatement(call.parent)) {
+                lowerer.unsupported("SC1090", call, "chaining process IPC listener registration (register each listener as its own statement)");
+            }
+            const callback = event === "message"
+                ? ipcMessageListener(lowerer, call.arguments[1])
+                : ipcDisconnectListener(lowerer, call.arguments[1]);
+            return {
+                kind: "libCall",
+                fn: event === "message" ? "process.onMessage" : "process.onDisconnect",
+                args: [callback, boolLit(member === "once", loc)],
+                type: VOID,
+                loc,
+            };
+        }
         // own(), not a bare index: the key is a USER-written event name,
         // and `{ SIGINT: 2 }["__proto__"]` answers Object.prototype — an
         // object flowed into a numLit and emitted itself into the C
@@ -6173,7 +6994,7 @@ export function lowerProcessMethodCall(lowerer, call, access) {
             };
         }
         if (signo === undefined && event !== "exit") {
-            lowerer.noLowering(`process.${member}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"SIGINT", "SIGTERM", "exit", "warning", "unhandledRejection", and "rejectionHandled" are the supported process events (as literals)');
+            lowerer.noLowering(`process.${member}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"message", "disconnect", "SIGINT", "SIGTERM", "exit", "warning", "unhandledRejection", and "rejectionHandled" are the supported process events (as literals)');
         }
         if (!ts.isExpressionStatement(call.parent)) {
             lowerer.unsupported("SC1090", call, "chaining process listener registration (the result is void here — register each listener as its own statement)");
@@ -6481,7 +7302,7 @@ export function lowerProcessMethodCall(lowerer, call, access) {
         const arg = call.arguments[0];
         const code = arg !== undefined
             ? lowerer.lowerExprExpecting(arg, F64)
-            : { kind: "numLit", value: 0, type: F64, loc };
+            : { kind: "libCall", fn: "process.currentExitCode", args: [], type: F64, loc };
         return { kind: "libCall", fn: "process.exit", args: [code], type: VOID, loc };
     }
     return null; // process.argv(...) etc. are tsc errors before lowering
@@ -6593,6 +7414,16 @@ export function lowerDateCall(lowerer, call, access) {
         }
         return { kind: "libCall", fn: "date.now", args: [], type: F64, loc };
     }
+    // Date.parse uses the same bounded date-string parser as
+    // new Date(dateString).getTime(); keep their NaN and TimeClip behavior
+    // identical for the ISO timestamps used by CLI applications.
+    if (lowerer.stdlibGlobalMember(access, "Date") === "parse") {
+        if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0])) {
+            lowerer.noLowering(`Date.parse with ${call.arguments.length} arguments`, call);
+        }
+        const input = lowerer.lowerExprExpecting(call.arguments[0], STRING);
+        return { kind: "libCall", fn: "date.parse", args: [input], type: F64, loc };
+    }
     // Date.UTC(year[, month[, date[, hours[, minutes[, seconds[, ms]]]]]]):
     // a pure function of its numbers — the runtime's MakeDay/MakeTime/
     // TimeClip. Omitted trailing arguments complete with the spec's
@@ -7432,6 +8263,8 @@ export function lowerProcessOptionalMethodCall(lowerer, expr) {
     if (!ts.isPropertyAccessExpression(expr.expression))
         return null;
     const member = lowerer.stdlibGlobalMember(expr.expression, "process");
+    if (member === "send")
+        return lowerProcessIpcSend(lowerer, expr);
     if (member !== "getuid" && member !== "getgid")
         return null;
     if (expr.arguments.length !== 0) {