@scriptc/compiler 0.1.2 → 0.1.3

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

@@ -24,7 +24,7 @@ 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 { 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")
@@ -2028,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
@@ -2044,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:
@@ -2062,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
@@ -2099,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)
@@ -2124,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)');
@@ -2146,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")
@@ -2190,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) {
@@ -3730,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;
@@ -3766,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)
@@ -3799,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
@@ -3829,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,
@@ -4465,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
@@ -4520,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;
@@ -4537,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,
@@ -4558,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);
@@ -4741,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