@scriptc/compiler 0.1.1 → 0.1.3

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

@@ -7,20 +7,24 @@ 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, locOf, requireSpecOf } from "../program.js";
+import { canonicalBuiltinModule, isJsSourceFile, isNodeEsmFile, locOf, requireSpecOf } 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 { conditionalSpreadOf, droppableStatic, lowerAbsenceProbe, lowerDynObjectLiteral } from "./lower-exprs.js";
+import { lowerAbsenceProbe } from "./lower-exprs.js";
+import { conditionalSpreadOf, lowerDynObjectLiteral } from "./expressions/object-literals.js";
+import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
+import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
 import { HTTP2_CONSTANTS } from "./http2-constants.js";
 import { CRYPTO_CIPHERS, CRYPTO_CONSTANTS, CRYPTO_CURVES, CRYPTO_HASHES } from "./crypto-tables.js";
-import { timerStyleCallback } from "./lower-calls.js";
+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 { 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";
 function optionalStringTags(lowerer, type) {
     if (type.kind !== "union")
@@ -32,6 +36,74 @@ function optionalStringTags(lowerer, type) {
     const undefinedTag = lowerer.armTag(type.unionId, UNDEFINED_T);
     return stringTag >= 0 && undefinedTag >= 0 ? { stringTag, undefinedTag } : null;
 }
+/** timers/promises.setInterval(delay, value), the first Node API built on
+ * the generic async-generator protocol. The supported form has an explicit
+ * value and no AbortSignal options. It lowers to a generated typed async
+ * generator whose loop awaits the existing promise timeout then yields the
+ * retained value; creating the iterator remains lazy. */
+export function lowerTimersPromisesSetInterval(lowerer, expr, bi, loc) {
+    if (bi.module !== "timers/promises" || bi.member !== "setInterval")
+        return null;
+    if (expr.arguments.some(ts.isSpreadElement)) {
+        lowerer.unsupported("SC1090", expr, "spread arguments");
+    }
+    if (expr.arguments.length !== 2) {
+        lowerer.noLowering(`timers/promises.setInterval with ${expr.arguments.length} arguments`, expr, "the lowered form is setInterval(delay, value) with an explicit yielded value; AbortSignal options are not supported yet");
+    }
+    const delayNode = expr.arguments[0];
+    const valueNode = expr.arguments[1];
+    const delay = lowerer.lowerExpr(delayNode);
+    const ms = delay.kind === "unitLit"
+        ? { kind: "numLit", value: 1, type: F64, loc }
+        : lowerer.coerceInto(delayNode, delay, F64);
+    const value = lowerer.lowerExpr(valueNode);
+    const callType = lowerer.mapTypeOf(lowerer.typeOf(expr));
+    if (callType?.kind !== "generator" || !callType.async) {
+        lowerer.badType(expr, lowerer.typeOf(expr));
+    }
+    const genT = callType;
+    const yielded = lowerer.coerceInto(valueNode, value, genT.yieldT);
+    const fnName = `%fn${lowerer.lambdaCounter++}_tpInterval`;
+    const msParam = { id: "%tp.ms", name: "delay", type: F64, mutable: false };
+    const valueParam = { id: "%tp.value", name: "value", type: genT.yieldT, mutable: false };
+    const promiseVoid = { kind: "promise", inner: VOID };
+    const msRef = () => ({ kind: "varRef", localId: msParam.id, type: F64, loc });
+    const valueRef = () => ({ kind: "varRef", localId: valueParam.id, type: genT.yieldT, loc });
+    const fn = {
+        name: fnName,
+        params: [
+            { localId: msParam.id, name: msParam.name, type: msParam.type },
+            { localId: valueParam.id, name: valueParam.name, type: valueParam.type },
+        ],
+        returnType: VOID,
+        locals: [msParam, valueParam],
+        async: true,
+        generator: generatorMeta(lowerer, genT),
+        body: [
+            {
+                kind: "while",
+                cond: { kind: "boolLit", value: true, type: BOOL, loc },
+                body: [
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "awaitExpr",
+                            value: { kind: "libCall", fn: "tp.setTimeout", args: [msRef()], type: promiseVoid, loc },
+                            type: VOID,
+                            loc,
+                        },
+                        loc,
+                    },
+                    { kind: "exprStmt", expr: { kind: "yieldExpr", value: valueRef(), type: VOID, loc }, loc },
+                ],
+                loc,
+            },
+        ],
+        loc,
+    };
+    lowerer.liftedFns.push(fn);
+    return { kind: "call", callee: fnName, args: [ms, yielded], type: genT, loc };
+}
 function lowerBuiltinValuePreservingUndefined(lowerer, node) {
     return lowerer.runtimeOptionalIdentifierValue(node)?.value ??
         lowerAbsenceProbe(lowerer, node) ??
@@ -90,49 +162,11 @@ function lowerOptionalNumberPredicate(lowerer, value, fn, loc) {
     }
     return { kind: "call", callee: helper, args: [value], type: BOOL, loc };
 }
-/** Lower an optional builtin argument whose checker type is statically
- * undefined/void. The returned expression exists only to preserve effects;
- * callers replace its value with the API default. */
-function lowerStaticallyUndefinedBuiltinArg(lowerer, node) {
-    const peel = (value) => {
-        let expr = value;
-        while (ts.isParenthesizedExpression(expr) ||
-            ts.isAsExpression(expr) ||
-            ts.isTypeAssertion(expr) ||
-            ts.isSatisfiesExpression(expr)) {
-            expr = expr.expression;
-        }
-        return expr;
-    };
-    let expr = node;
-    while (ts.isParenthesizedExpression(expr))
-        expr = expr.expression;
-    if ((lowerer.typeOf(expr).flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) === 0)
-        return null;
-    expr = peel(expr);
-    let sawVoid = false;
-    while (ts.isVoidExpression(expr)) {
-        sawVoid = true;
-        expr = peel(expr.expression);
-    }
-    return lowerer.lowerExpr(sawVoid ? expr : node);
-}
-function defaultAfterUndefined(value, dflt) {
-    if (droppableStatic(value))
-        return dflt;
-    return {
-        kind: "seqExpr",
-        stmts: [{ kind: "exprStmt", expr: value, loc: value.loc }],
-        result: dflt,
-        type: dflt.type,
-        loc: value.loc,
-    };
-}
 /** Complete an optional builtin argument. Statically undefined spellings
  * preserve their effects and select the default; a runtime unit-armed union
  * uses nullish selection when every non-unit arm is the expected type. */
 function lowerBuiltinOptionalDefault(lowerer, node, expected, dflt, nullIsDefault = false) {
-    const undefinedArg = lowerStaticallyUndefinedBuiltinArg(lowerer, node);
+    const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, node);
     if (undefinedArg)
         return defaultAfterUndefined(undefinedArg, dflt);
     if (nullIsDefault && (lowerer.typeOf(node).flags & ts.TypeFlags.Null) !== 0) {
@@ -502,6 +536,134 @@ export function lowerCreateRequireCall(lowerer, call, loc) {
         loc,
     };
 }
+function staticString(node) {
+    if (node === undefined)
+        return null;
+    const value = stripTypeCasts(node);
+    return ts.isStringLiteralLike(value) ? value.text : null;
+}
+function runtimeResolveThrow(error, type, loc) {
+    return nodeThrowExpr(error.name === "TypeError" ? 1 : 0, error.code, error.message, type, loc);
+}
+/** import.meta.resolve("literal") folds through the runtime-module
+ * resolver, never TypeScript's declaration-file resolver. Relative and
+ * URL-like names remain valid even when no file exists; bare packages use
+ * Node's import-condition exports path. */
+export function lowerImportMetaResolveCall(lowerer, call) {
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) || callee.questionDotToken !== undefined ||
+        callee.name.text !== "resolve" || !ts.isMetaProperty(callee.expression) ||
+        callee.expression.keywordToken !== ts.SyntaxKind.ImportKeyword ||
+        callee.expression.name.text !== "meta") {
+        return null;
+    }
+    if (call.questionDotToken !== undefined || call.arguments.length !== 1) {
+        lowerer.noLowering("import.meta.resolve with this argument shape", call, "the lowered form is import.meta.resolve(\"<static specifier>\") using the containing module as its parent");
+    }
+    const specifier = staticString(call.arguments[0]);
+    if (specifier === null) {
+        lowerer.noLowering("import.meta.resolve with a runtime-computed specifier", call.arguments[0], "a compiled binary has a fixed module graph — pass a string literal");
+    }
+    const result = resolveImportMetaRuntime(call.getSourceFile().fileName, specifier, lowerer.targetPlatform);
+    if (result === null) {
+        lowerer.noLowering(`import.meta.resolve of '${specifier}'`, call, "relative paths, URL-like names, builtins, and installed package names are supported; package-import aliases remain unsupported");
+    }
+    const loc = locOf(call);
+    return result.ok
+        ? { kind: "strLit", value: result.value, type: STRING, loc }
+        : runtimeResolveThrow(result.error, STRING, loc);
+}
+function requireResolverBaseFile(lowerer, receiver) {
+    const created = createRequireCalleeFileOf(lowerer, receiver);
+    if (created !== null)
+        return created;
+    return lowerer.isStdlibGlobal(receiver, "require") && !isNodeEsmFile(receiver.getSourceFile())
+        ? receiver.getSourceFile()
+        : null;
+}
+function staticResolveOptionPaths(node) {
+    if (node === undefined)
+        return undefined;
+    const value = stripTypeCasts(node);
+    if (ts.isIdentifier(value) && value.text === "undefined")
+        return undefined;
+    if (!ts.isObjectLiteralExpression(value))
+        return null;
+    let paths;
+    for (const prop of value.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            return null;
+        const name = ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name) ? prop.name.text : null;
+        if (name !== "paths" || paths !== undefined)
+            return null;
+        const init = stripTypeCasts(prop.initializer);
+        if (!ts.isArrayLiteralExpression(init))
+            return null;
+        const entries = [];
+        for (const item of init.elements) {
+            if (!ts.isStringLiteralLike(item))
+                return null;
+            entries.push(item.text);
+        }
+        paths = entries;
+    }
+    return paths;
+}
+/** CommonJS require.resolve and require.resolve.paths for the ambient
+ * wrapper or a supported createRequire binding. Results are build-time
+ * constants; failures lower to Node's catchable error object. */
+export function lowerRequireResolveCall(lowerer, call) {
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) || callee.questionDotToken !== undefined)
+        return null;
+    let receiver;
+    let pathsCall = false;
+    if (callee.name.text === "resolve") {
+        receiver = callee.expression;
+    }
+    else if (callee.name.text === "paths" && ts.isPropertyAccessExpression(callee.expression) &&
+        callee.expression.questionDotToken === undefined && callee.expression.name.text === "resolve") {
+        receiver = callee.expression.expression;
+        pathsCall = true;
+    }
+    else {
+        return null;
+    }
+    const baseFile = requireResolverBaseFile(lowerer, receiver);
+    if (baseFile === null)
+        return null;
+    if (call.questionDotToken !== undefined || call.arguments.length < 1 || call.arguments.length > (pathsCall ? 1 : 2)) {
+        lowerer.noLowering(pathsCall ? "require.resolve.paths with this argument shape" : "require.resolve with this argument shape", call);
+    }
+    const specifier = staticString(call.arguments[0]);
+    if (specifier === null) {
+        lowerer.noLowering(`${pathsCall ? "require.resolve.paths" : "require.resolve"} with a runtime-computed request`, call.arguments[0], "a compiled binary has a fixed module graph — pass a string literal");
+    }
+    const loc = locOf(call);
+    if (pathsCall) {
+        const result = requireResolvePathsRuntime(baseFile.fileName, specifier, lowerer.targetPlatform);
+        if (result !== null && !Array.isArray(result)) {
+            return runtimeResolveThrow(result, lowerer.irTypeOf(call), loc);
+        }
+        const raw = result === null
+            ? { kind: "unitLit", unit: "null", type: NULL_T, loc }
+            : {
+                kind: "arrayLit",
+                elems: result.map((value) => ({ kind: "strLit", value, type: STRING, loc })),
+                type: arrayOf(STRING),
+                loc,
+            };
+        return lowerer.coerceInto(call, raw, lowerer.irTypeOf(call));
+    }
+    const paths = staticResolveOptionPaths(call.arguments[1]);
+    if (paths === null) {
+        lowerer.noLowering("require.resolve with runtime-computed options", call.arguments[1], "omit options or pass { paths: [\"<static directory>\", ...] }");
+    }
+    const result = resolveRequireRuntime(baseFile.fileName, specifier, lowerer.targetPlatform, paths);
+    return result.ok
+        ? { kind: "strLit", value: result.value, type: STRING, loc }
+        : runtimeResolveThrow(result.error, STRING, loc);
+}
 /** The builtin modules whose `constants` object bakes as literals at
    * every access site (the fs.constants precedent, scaled up): http2's
    * full Node v24 table, and crypto's OpenSSL-constant table. The object
@@ -1866,13 +2028,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
@@ -1882,11 +2043,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, and windowsHide 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:
@@ -1900,8 +2078,7 @@ export function lowerSpawnCall(lowerer, expr, 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
@@ -1937,18 +2114,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)
@@ -1962,7 +2136,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)');
@@ -1984,13 +2158,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")
@@ -2028,7 +2200,8 @@ export function lowerSpawnCall(lowerer, expr, loc) {
         }
     }
     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;
     }
     const argv = lowerer.lowerChildArgsArg(argsNode, loc);
     if (plain) {
@@ -3568,9 +3741,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;
@@ -3604,16 +3777,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)
@@ -3637,16 +3803,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
@@ -3667,22 +3831,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 cryptoBytesCallback(lowerer, node) {
+    let callback = lowerer.lowerExpr(node);
+    if (callback.type.kind === "dyn") {
+        callback = { kind: "dynCheck", value: callback, type: funcOf([DYN, DYN], VOID), loc: locOf(node) };
+    }
+    if (callback.type.kind !== "func" || callback.type.params.length > 2) {
+        lowerer.unsupported("SC1090", node, "crypto callbacks must accept at most (error, buffer)");
+    }
+    const error = callback.type.params[0];
+    if (error !== undefined && error.kind !== "dyn") {
+        if (error.kind !== "union") {
+            lowerer.unsupported("SC1090", node, "crypto callback error parameters must be Error | null");
+        }
+        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, "crypto callback error parameters must be Error | null");
+    }
+    const value = callback.type.params[1];
+    if (value !== undefined && value.kind !== "dyn" && !(value.kind === "bytes" && value.elem === "u8")) {
+        lowerer.unsupported("SC1090", node, "crypto callback result parameters must be Buffer/Uint8Array values");
+    }
+    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), cryptoBytesCallback(lowerer, args[1])],
+            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"),
+                cryptoBytesCallback(lowerer, args[5]),
+            ],
+            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,
@@ -4094,7 +4430,7 @@ export function lowerFileHandleMethodCall(lowerer, call, access) {
         const defaultValue = { kind: "numLit", value: dflt, type: F64, loc };
         if (!node)
             return { value: defaultValue, defaulted: boolLit(true, loc) };
-        const undefinedArg = lowerStaticallyUndefinedBuiltinArg(lowerer, node);
+        const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, node);
         if (undefinedArg) {
             return { value: defaultAfterUndefined(undefinedArg, defaultValue), defaulted: boolLit(true, loc) };
         }
@@ -4303,6 +4639,85 @@ export function lowerStatsMethodCall(lowerer, call, access) {
     }
     lowerer.noLowering(`Stats.${name}`, call, "isFile(), isDirectory(), isSymbolicLink(), size, blocks, nlink, atimeMs, and mtimeMs 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
    * `Atomics.wait(sleepBuffer, 0, 0, ms)`): scriptc has no threads, so
@@ -4358,7 +4773,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;
@@ -4375,19 +4790,20 @@ 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,
@@ -4396,6 +4812,16 @@ export function lowerBuiltinExtraProperty(lowerer, expr) {
     }
     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")) {
         const receiver = lowerer.lowerExpr(expr.expression);
@@ -4579,6 +5005,67 @@ export function lowerChildStreamMethodCall(lowerer, call, access) {
     }
     lowerer.noLowering(`ReadableStream.${name}`, call, '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");
+        }
+        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(`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):
    * write(data) with one string, dispatched at runtime onto the exact
@@ -4862,6 +5349,15 @@ export function lowerProcessProperty(lowerer, expr) {
         const fn = expr.name.text === "node" ? "process.versionsNode" : "process.versionsOpenssl";
         return { kind: "libCall", fn, args: [], type: STRING, loc: locOf(expr) };
     }
+    // process.versions?.electron is the runtime-capability probe used by
+    // CLI packages to select Electron argument conventions. versions
+    // itself always exists, and a native scriptc binary is not Electron,
+    // so both the optional and ordinary property spellings read undefined.
+    if (ts.isPropertyAccessExpression(expr.expression) &&
+        lowerer.stdlibGlobalMember(expr.expression, "process") === "versions" &&
+        expr.name.text === "electron") {
+        return { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc: locOf(expr) };
+    }
     // The capability-probe members that honestly DON'T EXIST in a
     // compiled binary — each reads undefined (their declared types carry
     // the undefined arm), so feature probes take their documented
@@ -5472,10 +5968,10 @@ export function lowerProcessMethodCall(lowerer, call, access) {
             const secondNode = args[1];
             const thirdNode = args[2];
             const secondUndefined = secondNode
-                ? lowerStaticallyUndefinedBuiltinArg(lowerer, secondNode)
+                ? lowerStaticallyUndefinedArgument(lowerer, secondNode)
                 : null;
             const thirdUndefined = thirdNode
-                ? lowerStaticallyUndefinedBuiltinArg(lowerer, thirdNode)
+                ? lowerStaticallyUndefinedArgument(lowerer, thirdNode)
                 : null;
             const secondT = secondNode && !secondUndefined ? lowerer.mapTypeOf(lowerer.typeOf(secondNode)) : undefined;
             const callbackNode = args.length === 3 && !thirdUndefined
@@ -5512,7 +6008,7 @@ export function lowerProcessMethodCall(lowerer, call, access) {
                 if (canonical === raw)
                     return evaluated;
                 const normalized = { kind: "strLit", value: canonical, type: STRING, loc: locOf(encodingNode) };
-                return droppableStatic(evaluated)
+                return isSafeToDiscard(evaluated)
                     ? normalized
                     : {
                         kind: "seqExpr",
@@ -5577,9 +6073,9 @@ export function lowerProcessMethodCall(lowerer, call, access) {
                 // data and encoding, even though it schedules no callback. Strings
                 // already evaluate encoding while producing `bytes`; byte chunks
                 // fold both ignored argument effects into this final ABI slot.
-                if (thirdUndefined && !droppableStatic(thirdUndefined)) {
+                if (thirdUndefined && !isSafeToDiscard(thirdUndefined)) {
                     const effects = isBytes
-                        ? [encoding, thirdUndefined].filter((effect) => !droppableStatic(effect))
+                        ? [encoding, thirdUndefined].filter((effect) => !isSafeToDiscard(effect))
                         : [thirdUndefined];
                     runtimeEncoding = {
                         kind: "seqExpr",