@scriptc/compiler 0.1.2 → 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 { BOOL, BYTES_U8, CHILD_T, CHILDSTREAM_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 { 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 };
 }
@@ -2028,13 +2424,12 @@ export function lowerSpawnSyncCall(lowerer, expr, loc) {
     };
 }
 /** `spawn(command, args?, options)` → one cp.spawn / cp.spawnOpts
-   * libCall. The options argument must be an object LITERAL with an
-   * EXPLICIT stdio — "ignore" or "inherit" as the scalar, or the 3-tuple
-   * whose stdout/stderr slots may also be "pipe" (the child.stdout/
-   * child.stderr streams) or number fds; piped STDIN fences, and
-   * OMITTING the options means Node's default stdio, "pipe" on all
-   * three — fenced too, so a program never silently loses its child's
-   * output. The other lowered
+   * libCall. The options argument, when present, must be an object
+   * LITERAL. Stdio accepts "ignore", "inherit", or "pipe" as the scalar,
+   * or the 3-tuple whose stdin pipe becomes child.stdin, stdout/stderr
+   * pipes become child.stdout/child.stderr, and output slots may also be
+   * number fds. Omitting stdio uses Node's default: all three piped. The
+   * other lowered
    * members: `detached` (a boolean literal, inline or carried by the
    * conditional spread `...(c ? { detached: true } : {})` in either
    * orientation — POSIX_SPAWN_SETSID, the child gets its own session and
@@ -2044,11 +2439,28 @@ export function lowerSpawnSyncCall(lowerer, expr, loc) {
    * keeps its historical cp.spawn lowering. */
 export function lowerSpawnCall(lowerer, expr, loc) {
     if (expr.arguments.length > 3 || expr.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering("spawn with this argument shape", expr, 'the supported form is spawn(command, args?, { stdio: "ignore" | "inherit", detached?, env?, cwd? })');
+        lowerer.noLowering("spawn with this argument shape", expr, 'the supported form is spawn(command, args?, { stdio: "pipe" | "ignore" | "inherit", detached?, env?, cwd? })');
     }
     const cmd = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-    const argsNode = expr.arguments.length === 3 ? expr.arguments[1] : undefined;
-    const optsNode = expr.arguments[expr.arguments.length - 1];
+    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("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
     // the out/err fd expressions for mode 2 (the daemon-log idiom:
@@ -2058,12 +2470,13 @@ 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;
     let plain = true; // exactly { stdio: "ignore" }: the historical libCall
-    const pipeFence = (node) => lowerer.noLowering('spawn with stdio: "pipe"', node, 'piped STDIN has no lowering — pipe stdout/stderr with the tuple form (stdio: ["ignore", "pipe", "pipe"]), or capture with spawnSync');
-    if (optsNode && ts.isObjectLiteralExpression(optsNode) && expr.arguments.length >= 2) {
+    if (optsNode && ts.isObjectLiteralExpression(optsNode)) {
         for (const p of optsNode.properties) {
             // The conditional-spread idiom `...(isWindows ? {} : { detached:
             // true })` (either orientation): the one carried member supported
@@ -2099,18 +2512,15 @@ export function lowerSpawnCall(lowerer, expr, loc) {
             }
             switch (m.name) {
                 case "stdio": {
-                    // The 3-tuple form: stdin a "ignore"/"inherit" literal,
-                    // stdout/stderr each a literal (including "pipe" — the
-                    // child.stdout/stderr stream slots) OR a number-typed fd (an
-                    // openSync result — dup2'd into the child, Node's fd slots).
+                    // The 3-tuple form: every slot accepts a literal, including
+                    // "pipe" (child.stdin/stdout/stderr); stdout/stderr also accept
+                    // a number-typed fd (an openSync result — dup2'd into the child).
                     if (ts.isArrayLiteralExpression(m.value) && m.value.elements.length === 3) {
                         const slot = (el, which) => {
                             const t = lowerer.typeOf(el);
                             if (t.isStringLiteralType()) {
-                                if (t.value === "pipe" && which === 0)
-                                    pipeFence(el);
                                 if (t.value !== "ignore" && t.value !== "inherit" && t.value !== "pipe") {
-                                    lowerer.noLowering(`spawn with stdio "${t.value}"`, el, '"ignore", "inherit", "pipe" (stdout/stderr), and number fds are the supported stdio slots');
+                                    lowerer.noLowering(`spawn with stdio "${t.value}"`, el, '"ignore", "inherit", "pipe", and number output fds are the supported stdio slots');
                                 }
                                 const mode = t.value === "inherit" ? 1 : t.value === "pipe" ? 3 : 0;
                                 if (which === 0)
@@ -2124,7 +2534,7 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                                 return;
                             }
                             if (which === 0) {
-                                lowerer.noLowering("spawn with this stdin slot", el, 'stdin takes "ignore" or "inherit" (fd stdin has no lowering)');
+                                lowerer.noLowering("spawn with this stdin slot", el, 'stdin takes "pipe", "ignore", or "inherit" (fd stdin has no lowering)');
                             }
                             if (lowerer.mapTypeOf(t)?.kind !== "f64") {
                                 lowerer.noLowering("spawn with this stdio option", el, 'each slot is "ignore", "inherit", or a number fd (an openSync result)');
@@ -2146,13 +2556,11 @@ export function lowerSpawnCall(lowerer, expr, loc) {
                     }
                     const t = lowerer.typeOf(m.value);
                     const v = t.isStringLiteralType() ? t.value : null;
-                    if (v === "pipe")
-                        pipeFence(m.value);
-                    if (v !== "ignore" && v !== "inherit") {
-                        lowerer.noLowering("spawn with this stdio option", m.value, '"ignore" and "inherit" are the supported stdio literals ' +
-                            '(or a 3-tuple of those and number fds; "pipe" has no lowering)');
+                    if (v !== "pipe" && v !== "ignore" && v !== "inherit") {
+                        lowerer.noLowering("spawn with this stdio option", m.value, '"pipe", "ignore", and "inherit" are the supported stdio literals ' +
+                            "(or a 3-tuple of those and number output fds)");
                     }
-                    const mode = v === "inherit" ? 1 : 0;
+                    const mode = v === "inherit" ? 1 : v === "pipe" ? 3 : 0;
                     inMode = outMode = errMode = mode;
                     sawStdio = true;
                     if (v !== "ignore")
@@ -2184,13 +2592,33 @@ 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");
             }
         }
     }
     if (!sawStdio) {
-        lowerer.noLowering("spawn without { stdio: \"ignore\" }", expr, 'Node\'s default stdio is "pipe" (streams, no lowering) — pass { stdio: "ignore" } or { stdio: "inherit" } explicitly, or capture with spawnSync');
+        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) {
@@ -2199,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
@@ -2703,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))
@@ -2723,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
@@ -2737,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:
@@ -3730,9 +4393,9 @@ export function fencedBuiltinImportOf(lowerer, ident) {
 /** The composed crypto pattern: `randomBytes(n).toString(enc)` lowers
    * as ONE string-producing libCall — the Buffer between the two calls
    * never exists at runtime. Only literal "hex"/"base64" encodings lower
-   * (the runtime implements exactly those); everything else — including a
-   * bare randomBytes(n) — fences with the Buffer story. Null when this
-   * isn't a toString on a crypto.randomBytes call. */
+   * (the runtime implements exactly those); wider forms fall through to
+   * the ordinary Buffer lowering. Null when this is not a toString on a
+   * crypto.randomBytes call. */
 export function lowerCryptoComposedCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
@@ -3766,16 +4429,9 @@ export function lowerCryptoComposedCall(lowerer, call, access) {
     const enc = lowerer.lowerExprExpecting(encNode, STRING);
     return { kind: "libCall", fn: "crypto.randomBytesToString", args: [size, enc], type: STRING, loc };
 }
-/** The composed hash chain — `createHash("sha256").update(data).digest("hex")`
-   * — fused into ONE libCall: the Hash handle never materializes (no Hash
-   * type exists in the value model), exactly the randomBytesToString
-   * stance. Both import spellings reach here (the named `createHash(...)`
-   * and the namespace `crypto.createHash(...)`). Once the chain is
-   * recognized, the narrow forms FENCE with pointed hints instead of
-   * falling to the generic member fence: sha256 is the lowered algorithm,
-   * one string- or Buffer-typed update, hex digests. Null when the callee
-   * isn't this chain at all (other Hash-typed code lands on the ordinary
-   * Hash.<member> fences). */
+/** Fast path for the exact single-update hash chain. Wider algorithms,
+   * stored handles, multiple updates, Buffer digests, and input encodings
+   * fall through to the first-class Hash lowering below. */
 function lowerHashDigestChain(lowerer, call, access) {
     const updateCall = access.expression;
     if (!ts.isCallExpression(updateCall) || updateCall.questionDotToken)
@@ -3799,16 +4455,14 @@ function lowerHashDigestChain(lowerer, call, access) {
         return null;
     const loc = locOf(call);
     const algT = chCall.arguments.length === 1 ? lowerer.typeOf(chCall.arguments[0]) : undefined;
-    if (!algT?.isStringLiteralType() || (algT.value !== "sha256" && algT.value !== "sha1")) {
-        lowerer.noLowering("createHash with this algorithm", chCall, 'sha256 and sha1 are the lowered algorithms: createHash("sha256") ' +
-            "(sha1 exists for the RFC 6455 Sec-WebSocket-Accept hash)");
-    }
+    if (!algT?.isStringLiteralType() || (algT.value !== "sha256" && algT.value !== "sha1"))
+        return null;
     if (updateCall.arguments.length !== 1) {
-        lowerer.noLowering(`Hash.update with ${updateCall.arguments.length} arguments`, updateCall, "one string or Buffer argument is the lowered update (input encodings have no lowering)");
+        return null;
     }
     const encT = call.arguments.length === 1 ? lowerer.typeOf(call.arguments[0]) : undefined;
     if (!encT?.isStringLiteralType() || (encT.value !== "hex" && encT.value !== "base64")) {
-        lowerer.noLowering("Hash.digest with this encoding", call, 'hex and base64 are the lowered digests: .digest("hex") (the bare Buffer digest has no lowering)');
+        return null;
     }
     // alg and enc are proven literals (fenced above), so lowering them
     // out of source position observes nothing; the data lowers between
@@ -3829,22 +4483,194 @@ function lowerHashDigestChain(lowerer, call, access) {
         const enc = lowerer.lowerExprExpecting(call.arguments[0], STRING);
         return { kind: "libCall", fn: "crypto.hashDigestStr", args: [alg, data, enc], type: STRING, loc };
     }
-    lowerer.noLowering(`Hash.update of '${dataIr ? lowerer.fmt(dataIr) : lowerer.checker.typeToString(lowerer.typeOf(dataNode))}' values`, dataNode, "string and Buffer/Uint8Array inputs are the lowered update forms");
-}
-/** The node:crypto introspection statics — build-time constants of the
-   * compiled runtime, baked at the call site (the http2.constants stance
-   * extended to calls): getFips() answers 0 (no FIPS provider can ever
-   * load into a compiled binary — Node's own answer for a non-FIPS
-   * build), and getCiphers()/getHashes()/getCurves() answer Node v24's
-   * name lists as fresh string[] literals. The lists are INTROSPECTION
-   * data (Node's contract is "names the provider recognizes"); the
-   * operations behind the names keep their per-member fences — a program
-   * that probes the list and then constructs a cipher fences at the
-   * construction site, never here. Null for other members (the dispatch
-   * keeps trying). */
+    return null;
+}
+function cryptoEncoding(lowerer, node, use) {
+    const type = lowerer.typeOf(node);
+    if (!type.isStringLiteralType() || (type.value !== "hex" && type.value !== "base64")) {
+        lowerer.noLowering(`${use} with this encoding`, node, 'the lowered output encodings are "hex" and "base64"');
+    }
+    return lowerer.lowerExprExpecting(node, STRING);
+}
+function cryptoAlgorithm(lowerer, node, use) {
+    const type = lowerer.typeOf(node);
+    if (type.isStringLiteralType() && !["md5", "sha1", "sha256"].includes(type.value.toLowerCase())) {
+        lowerer.noLowering(`${use} with algorithm '${type.value}'`, node, "md5, sha1, and sha256 are the lowered digest algorithms");
+    }
+    return lowerer.lowerExprExpecting(node, STRING);
+}
+function cryptoInputBytes(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(`crypto byte input of '${lowerer.fmt(value.type)}' values`, node, "string and Buffer/Uint8Array values are supported");
+}
+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, `${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, `${api} callback error parameters must be Error | null`);
+        }
+        const def = lowerer.unions.get(error.unionId);
+        const valid = !!def &&
+            def.arms.some((arm) => arm.kind === "nullT") &&
+            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, `${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, `${api} callback result parameters must be Buffer/Uint8Array values`);
+    }
+    return voidizedCallback(lowerer, callback, locOf(node));
+}
+/** The node:crypto utility and introspection statics. Hash/Hmac are real
+   * native handles; one-shot hashing, constant-time equality, random-fill/
+   * integer, and PBKDF2 share the same runtime primitives as the island.
+   * The name lists remain build-time constants. */
 export function lowerCryptoModuleCall(lowerer, expr, bi, loc) {
     if (bi.module !== "crypto")
         return null;
+    const args = expr.arguments;
+    if (args.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`crypto.${bi.member} with spread arguments`, expr);
+    }
+    if (bi.member === "randomBytes") {
+        if (args.length === 1)
+            return null;
+        if (args.length !== 2) {
+            lowerer.noLowering(`crypto.randomBytes with ${args.length} arguments`, expr, "randomBytes(size) and randomBytes(size, callback) are supported");
+        }
+        return {
+            kind: "libCall",
+            fn: "crypto.randomBytesCb",
+            args: [lowerer.lowerExprExpecting(args[0], F64), errorFirstBytesCallback(lowerer, args[1], "crypto")],
+            type: VOID,
+            loc,
+        };
+    }
+    if (bi.member === "pbkdf2") {
+        if (args.length !== 6) {
+            lowerer.noLowering(`crypto.pbkdf2 with ${args.length} arguments`, expr, "pbkdf2(password, salt, iterations, keylen, digest, callback) is supported");
+        }
+        return {
+            kind: "libCall",
+            fn: "crypto.pbkdf2Cb",
+            args: [
+                cryptoInputBytes(lowerer, args[0], locOf(args[0])),
+                cryptoInputBytes(lowerer, args[1], locOf(args[1])),
+                lowerer.lowerExprExpecting(args[2], F64),
+                lowerer.lowerExprExpecting(args[3], F64),
+                cryptoAlgorithm(lowerer, args[4], "crypto.pbkdf2"),
+                errorFirstBytesCallback(lowerer, args[5], "crypto"),
+            ],
+            type: VOID,
+            loc,
+        };
+    }
+    if (bi.member === "createHash") {
+        if (args.length !== 1) {
+            lowerer.noLowering(`crypto.createHash with ${args.length} arguments`, expr, "createHash(algorithm) is supported; options are not yet lowered");
+        }
+        return { kind: "libCall", fn: "crypto.hashNew", args: [cryptoAlgorithm(lowerer, args[0], "crypto.createHash")], type: CRYPTOHASH_T, loc };
+    }
+    if (bi.member === "createHmac") {
+        if (args.length !== 2) {
+            lowerer.noLowering(`crypto.createHmac with ${args.length} arguments`, expr, "createHmac(algorithm, stringOrBufferKey) is supported; options and KeyObject keys are not yet lowered");
+        }
+        const algorithm = cryptoAlgorithm(lowerer, args[0], "crypto.createHmac");
+        const key = lowerer.lowerExpr(args[1]);
+        if (key.type.kind === "string") {
+            return { kind: "libCall", fn: "crypto.hmacNewStr", args: [algorithm, key], type: CRYPTOHMAC_T, loc };
+        }
+        if (key.type.kind === "bytes" && key.type.elem === "u8") {
+            return { kind: "libCall", fn: "crypto.hmacNewBytes", args: [algorithm, key], type: CRYPTOHMAC_T, loc };
+        }
+        lowerer.noLowering(`crypto.createHmac with a '${lowerer.fmt(key.type)}' key`, args[1], "string and Buffer/Uint8Array keys are supported");
+    }
+    if (bi.member === "hash") {
+        if (args.length < 2 || args.length > 3) {
+            lowerer.noLowering(`crypto.hash with ${args.length} arguments`, expr, "hash(algorithm, stringOrBuffer[, \"hex\" | \"base64\"]) is supported");
+        }
+        const algorithm = cryptoAlgorithm(lowerer, args[0], "crypto.hash");
+        const data = lowerer.lowerExpr(args[1]);
+        const encoding = args[2]
+            ? cryptoEncoding(lowerer, args[2], "crypto.hash")
+            : { kind: "strLit", value: "hex", type: STRING, loc };
+        if (data.type.kind === "string") {
+            return { kind: "libCall", fn: "crypto.hashDigestStr", args: [algorithm, data, encoding], type: STRING, loc };
+        }
+        if (data.type.kind === "bytes" && data.type.elem === "u8") {
+            return { kind: "libCall", fn: "crypto.hashDigestBytes", args: [algorithm, data, encoding], type: STRING, loc };
+        }
+        lowerer.noLowering(`crypto.hash of '${lowerer.fmt(data.type)}' data`, args[1], "string and Buffer/Uint8Array data are supported");
+    }
+    if (bi.member === "timingSafeEqual") {
+        if (args.length !== 2)
+            lowerer.noLowering(`crypto.timingSafeEqual with ${args.length} arguments`, expr);
+        return {
+            kind: "libCall",
+            fn: "crypto.timingSafeEqual",
+            args: [lowerer.lowerExprExpecting(args[0], BYTES_U8), lowerer.lowerExprExpecting(args[1], BYTES_U8)],
+            type: BOOL,
+            loc,
+        };
+    }
+    if (bi.member === "randomFillSync") {
+        if (args.length < 1 || args.length > 3) {
+            lowerer.noLowering(`crypto.randomFillSync with ${args.length} arguments`, expr, "randomFillSync(buffer[, offset[, size]]) is supported");
+        }
+        const buffer = lowerer.lowerExprExpecting(args[0], BYTES_U8);
+        const offset = args[1]
+            ? lowerer.lowerExprExpecting(args[1], F64)
+            : { kind: "numLit", value: 0, type: F64, loc };
+        if (args[2]) {
+            const size = lowerer.lowerExprExpecting(args[2], F64);
+            return { kind: "libCall", fn: "crypto.randomFill", args: [buffer, offset, size], type: BYTES_U8, loc };
+        }
+        return { kind: "libCall", fn: "crypto.randomFillRest", args: [buffer, offset], type: BYTES_U8, loc };
+    }
+    if (bi.member === "randomInt") {
+        if (args.length !== 1 && args.length !== 2) {
+            lowerer.noLowering(`crypto.randomInt with ${args.length} arguments`, expr, "the synchronous randomInt(max) and randomInt(min, max) forms are supported");
+        }
+        const min = args.length === 1
+            ? { kind: "numLit", value: 0, type: F64, loc }
+            : lowerer.lowerExprExpecting(args[0], F64);
+        const max = lowerer.lowerExprExpecting(args[args.length - 1], F64);
+        return { kind: "libCall", fn: "crypto.randomInt", args: [min, max], type: F64, loc };
+    }
+    if (bi.member === "pbkdf2Sync") {
+        if (args.length !== 5) {
+            lowerer.noLowering(`crypto.pbkdf2Sync with ${args.length} arguments`, expr, "pbkdf2Sync(password, salt, iterations, keylen, digest) is supported");
+        }
+        const password = cryptoInputBytes(lowerer, args[0], locOf(args[0]));
+        const salt = cryptoInputBytes(lowerer, args[1], locOf(args[1]));
+        return {
+            kind: "libCall",
+            fn: "crypto.pbkdf2",
+            args: [password, salt, lowerer.lowerExprExpecting(args[2], F64), lowerer.lowerExprExpecting(args[3], F64), cryptoAlgorithm(lowerer, args[4], "crypto.pbkdf2Sync")],
+            type: BYTES_U8,
+            loc,
+        };
+    }
     const LISTS = {
         getCiphers: CRYPTO_CIPHERS,
         getHashes: CRYPTO_HASHES,
@@ -3881,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,
@@ -4463,7 +5289,86 @@ 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,
+   * digest() finalizes it, and Hash.copy() snapshots the incremental state. */
+export function lowerCryptoHashMethodCall(lowerer, call, access) {
+    if (call.questionDotToken || access.questionDotToken)
+        return null;
+    const receiverType = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    if (receiverType?.kind !== "cryptoHash" && receiverType?.kind !== "cryptoHmac")
+        return null;
+    if (!lowerer.isStdlibMember(access))
+        return null;
+    const name = access.name.text;
+    const loc = locOf(call);
+    const receiver = () => lowerer.lowerExprExpecting(access.expression, receiverType);
+    if (name === "update") {
+        if (call.arguments.length < 1 || call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`${receiverType.kind === "cryptoHash" ? "Hash" : "Hmac"}.update with ${call.arguments.length} arguments`, call, "update(stringOrBuffer[, inputEncoding]) is supported");
+        }
+        const dataNode = call.arguments[0];
+        const data = lowerer.lowerExpr(dataNode);
+        const prefix = receiverType.kind === "cryptoHash" ? "crypto.hashUpdate" : "crypto.hmacUpdate";
+        if (data.type.kind === "bytes" && data.type.elem === "u8") {
+            if (call.arguments.length !== 1) {
+                lowerer.noLowering("Hash/Hmac.update with an encoding for Buffer data", call.arguments[1], "input encodings apply only to string data");
+            }
+            return { kind: "libCall", fn: `${prefix}Bytes`, args: [receiver(), data], type: receiverType, loc };
+        }
+        if (data.type.kind === "string") {
+            const encodingNode = call.arguments[1];
+            if (encodingNode === undefined) {
+                return { kind: "libCall", fn: `${prefix}Str`, args: [receiver(), data], type: receiverType, loc };
+            }
+            const encodingType = lowerer.typeOf(encodingNode);
+            if (!encodingType.isStringLiteralType() || !["utf8", "utf-8", "hex", "base64"].includes(encodingType.value)) {
+                lowerer.noLowering("Hash/Hmac.update with this input encoding", encodingNode, 'utf8, hex, and base64 string inputs are supported');
+            }
+            if (encodingType.value === "utf8" || encodingType.value === "utf-8") {
+                lowerer.lowerExprExpecting(encodingNode, STRING);
+                return { kind: "libCall", fn: `${prefix}Str`, args: [receiver(), data], type: receiverType, loc };
+            }
+            const encoded = {
+                kind: "libCall",
+                fn: "buffer.fromStr",
+                args: [data, lowerer.lowerExprExpecting(encodingNode, STRING)],
+                type: BYTES_U8,
+                loc,
+            };
+            return { kind: "libCall", fn: `${prefix}Bytes`, args: [receiver(), encoded], type: receiverType, loc };
+        }
+        lowerer.noLowering(`Hash/Hmac.update of '${lowerer.fmt(data.type)}' values`, dataNode, "string and Buffer/Uint8Array inputs are supported");
+    }
+    if (name === "digest") {
+        if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`${receiverType.kind === "cryptoHash" ? "Hash" : "Hmac"}.digest with ${call.arguments.length} arguments`, call, 'digest() and digest("hex" | "base64") are supported');
+        }
+        if (call.arguments.length === 0) {
+            return {
+                kind: "libCall",
+                fn: receiverType.kind === "cryptoHash" ? "crypto.hashDigestBuffer" : "crypto.hmacDigestBuffer",
+                args: [receiver()],
+                type: BYTES_U8,
+                loc,
+            };
+        }
+        return {
+            kind: "libCall",
+            fn: receiverType.kind === "cryptoHash" ? "crypto.hashDigestString" : "crypto.hmacDigestString",
+            args: [receiver(), cryptoEncoding(lowerer, call.arguments[0], `${receiverType.kind === "cryptoHash" ? "Hash" : "Hmac"}.digest`)],
+            type: STRING,
+            loc,
+        };
+    }
+    if (name === "copy" && receiverType.kind === "cryptoHash") {
+        if (call.arguments.length !== 0)
+            lowerer.noLowering(`Hash.copy with ${call.arguments.length} arguments`, call, "copy() without options is supported");
+        return { kind: "libCall", fn: "crypto.hashCopy", args: [receiver()], type: CRYPTOHASH_T, loc };
+    }
+    lowerer.noLowering(`${receiverType.kind === "cryptoHash" ? "Hash" : "Hmac"}.${name}`, call, receiverType.kind === "cryptoHash" ? "update(), digest(), and copy() are supported" : "update() and digest() are supported", lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** `Atomics.wait(int32Array, idx, expected, timeoutMs)` — the
    * synchronous-sleep idiom (RouteStore's
@@ -4520,7 +5425,7 @@ export function lowerBuiltinExtraProperty(lowerer, expr) {
         return { kind: "recordGet", obj: receiver, shapeId: receiver.type.shapeId, field: "%enc", type: STRING, loc: locOf(expr) };
     }
     const kind = lowerer.mapTypeOf(lowerer.typeOf(expr.expression))?.kind;
-    if (kind !== "stats" && kind !== "fileHandle" && kind !== "spawnRes" && kind !== "child")
+    if (kind !== "stats" && kind !== "fileHandle" && kind !== "spawnRes" && kind !== "child" && kind !== "childWriter")
         return null;
     if (kind === "child" ? !isChildSurfaceMember(lowerer, expr) : !lowerer.isStdlibMember(expr))
         return null;
@@ -4537,29 +5442,50 @@ export function lowerBuiltinExtraProperty(lowerer, expr) {
         }
         lowerer.noLowering(`FileHandle.${name}`, expr, "fd, close(), read(), write(), readFile(), writeFile(), appendFile(), and stat() are the supported FileHandle members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
-    // child.stdout / child.stderr — the piped-output streams: the
-    // checker's `Readable | null` (null exactly when the slot was not
-    // piped), constructed type-directedly in the backend over the
+    // child.stdin/stdout/stderr — the piped streams: the checker's
+    // `Writable | null` / `Readable | null` (null exactly when the slot
+    // was not piped), constructed type-directedly in the backend over the
     // +1-or-NULL runtime pair.
-    if (kind === "child" && (name === "stdout" || name === "stderr")) {
+    if (kind === "child" && (name === "stdin" || name === "stdout" || name === "stderr")) {
         const receiver = lowerer.lowerExpr(expr.expression);
+        const streamType = name === "stdin" ? CHILDWRITER_T : CHILDSTREAM_T;
         const type = {
             kind: "union",
-            unionId: lowerer.unions.intern([CHILDSTREAM_T, { kind: "nullT" }]),
+            unionId: lowerer.unions.intern([streamType, { kind: "nullT" }]),
         };
         const read = {
             kind: "libCall",
-            fn: name === "stdout" ? "child.stdout" : "child.stderr",
+            fn: name === "stdin" ? "child.stdin" : name === "stdout" ? "child.stdout" : "child.stderr",
             args: [receiver],
             type,
             loc,
         };
         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") {
+        if (name === "writable") {
+            const receiver = lowerer.lowerExprExpecting(expr.expression, CHILDWRITER_T);
+            return { kind: "libCall", fn: "writer.writable", args: [receiver], type: BOOL, loc };
+        }
+        if (name === "write" || name === "end" || name === "destroy" || name === "on" || name === "once") {
+            lowerer.unsupported("SC1090", expr, `child stdin methods as values (call '${name}' directly)`);
+        }
+        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 };
@@ -4586,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;
@@ -4595,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") {
@@ -4618,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" &&
                     (() => {
@@ -4628,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
@@ -4643,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)}')`);
@@ -4684,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").
@@ -4706,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;
@@ -4734,12 +5765,73 @@ 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: param?.kind === "string" ? "stream.onDataStr" : "stream.onData", args: [receiver, cb, once], type: VOID, loc };
+    }
+    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
+ * signal. end()/destroy() are statement-only, as are drain/finish/error
+ * listener registrations; unsupported callbacks/encodings stay fenced. */
+export function lowerChildWriterMethodCall(lowerer, call, access) {
+    if (lowerer.chainBlocked(call, access))
+        return null;
+    if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "childWriter")
+        return null;
+    if (!lowerer.isStdlibMember(access))
+        return null;
+    const name = access.name.text;
+    const loc = locOf(call);
+    if (name === "write") {
+        if (call.arguments.length !== 1 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`child stdin write with ${call.arguments.length} arguments`, call, "write(string | Uint8Array) with no encoding or callback is supported");
+        }
+        const receiver = lowerer.lowerExprExpecting(access.expression, CHILDWRITER_T);
+        const data = lowerer.lowerExpr(call.arguments[0]);
+        if (data.type.kind === "string") {
+            return { kind: "libCall", fn: "writer.writeString", args: [receiver, data], type: BOOL, loc };
+        }
+        if (data.type.kind === "bytes" && data.type.elem === "u8") {
+            return { kind: "libCall", fn: "writer.writeBytes", args: [receiver, data], type: BOOL, loc };
+        }
+        lowerer.noLowering(`child stdin write of '${lowerer.fmt(data.type)}'`, call.arguments[0], "write one string, Buffer, or Uint8Array value (narrow unions first)");
+    }
+    if ((name === "end" || name === "destroy") && call.arguments.length === 0) {
+        if (!ts.isExpressionStatement(call.parent)) {
+            lowerer.unsupported("SC1090", call, `chaining child.stdin.${name}() (call it as its own statement)`);
+        }
+        const receiver = lowerer.lowerExprExpecting(access.expression, CHILDWRITER_T);
+        return { kind: "libCall", fn: name === "end" ? "writer.end" : "writer.destroy", args: [receiver], type: VOID, loc };
+    }
+    if ((name === "on" || name === "once") && call.arguments.length === 2) {
+        const eventType = lowerer.typeOf(call.arguments[0]);
+        const event = eventType.isStringLiteralType() ? eventType.value : null;
+        if (event !== "drain" && event !== "finish" && event !== "error") {
+            lowerer.noLowering(`child stdin ${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"drain", "finish", and "error" are the supported child stdin events');
+        }
+        if (!ts.isExpressionStatement(call.parent)) {
+            lowerer.unsupported("SC1090", call, "chaining child stdin listener registration");
         }
-        return { kind: "libCall", fn: "stream.onData", args: [receiver, cb, once], type: VOID, loc };
+        const receiver = lowerer.lowerExprExpecting(access.expression, CHILDWRITER_T);
+        const cb = lowerer.lowerExpr(call.arguments[1]);
+        const maxParams = event === "error" ? 1 : 0;
+        if (cb.type.kind !== "func" || cb.type.ret.kind !== "void" || cb.type.params.length > maxParams) {
+            lowerer.unsupported("SC1090", call.arguments[1], event === "error"
+                ? "error listeners with at most one Error parameter and no return value"
+                : `${event} listeners with no parameters or return value`);
+        }
+        if (event === "error" && cb.type.params[0] !== undefined &&
+            !(cb.type.params[0].kind === "object" && cb.type.params[0].className === "%Error")) {
+            lowerer.unsupported("SC1090", call.arguments[1], "child stdin error listeners whose parameter is Error");
+        }
+        const once = boolLit(name === "once", loc);
+        const fn = event === "drain" ? "writer.onDrain" : event === "finish" ? "writer.onFinish" : "writer.onError";
+        return { kind: "libCall", fn, 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(`Writable.${name}`, call, 'write(string | Uint8Array), end(), destroy(), and on/once("drain" | "finish" | "error", cb) are supported', lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** Method calls on first-class process-stream receivers (procStream —
    * a WritableStream-typed value like prefixStream's `output` param):
@@ -4965,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");
@@ -5074,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") {
@@ -5152,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);
@@ -5205,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
@@ -5539,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
@@ -5806,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
@@ -5848,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)");
@@ -6156,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
@@ -6268,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
@@ -7107,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) {