@scriptc/compiler 0.2.1 → 0.2.2

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

@@ -1,4 +1,5 @@
 import { staticTextDecoderEncoding } from "./text-decoder-encoding.js";
+import { checkedPromiseAll } from "./checked-promise-all.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Builtin-surface lowering: node builtin-module calls (fs, path, os, url,
  * crypto, child_process spawn/spawnSync and child/stats/spawn-result
@@ -1414,12 +1415,36 @@ function lowerZlibModuleCall(lowerer, expr, bi, loc) {
 }
 export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     const name = expr.expression.getText();
+    if (bi.module === "process" && bi.member === "loadEnvFile")
+        return lowerProcessLoadEnvFile(lowerer, expr);
+    if (bi.module === "buffer" && ["isAscii", "isUtf8", "transcode"].includes(bi.member)) {
+        if (expr.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering("buffer encoding call with spread arguments", expr);
+        const arity = bi.member === "transcode" ? 3 : 1;
+        const args = Array.from({ length: arity }, (_, index) => expr.arguments[index]
+            ? lowerer.lowerExprExpecting(stripTypeCasts(expr.arguments[index]), DYN) : dynUndefinedExpr(loc));
+        if (expr.arguments.length > arity)
+            lowerer.noLowering("buffer encoding call with extra arguments", expr);
+        return { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
+    }
     if (fn.fn === "fs.callbackCall" && bi.member !== "rename") {
         if (expr.arguments.some(ts.isSpreadElement))
             lowerer.noLowering("filesystem callback call with spread arguments", expr);
         const args = { kind: "dynArrLit", elems: expr.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc };
         return { kind: "libCall", fn: "fs.callbackCall", args: [{ kind: "strLit", value: bi.member, type: STRING, loc }, args], type: DYN, loc };
     }
+    if (bi.module === "fs" && (bi.member === "readvSync" || bi.member === "writevSync" || bi.member === "ftruncateSync")) {
+        const vector = bi.member !== "ftruncateSync";
+        const required = vector ? 2 : 1;
+        if (expr.arguments.length < required || expr.arguments.length > required + 1 || expr.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering(`${name} with this argument shape`, expr);
+        const args = [lowerer.lowerExprExpecting(expr.arguments[0], F64)];
+        if (vector)
+            args.push(lowerer.lowerExprExpecting(expr.arguments[1], arrayOf(BYTES_U8)));
+        const optional = expr.arguments[required];
+        args.push(optional ? lowerBuiltinOptionalDefault(lowerer, optional, F64, numLit(vector ? -1 : 0, loc), vector) : numLit(vector ? -1 : 0, loc));
+        return { kind: "libCall", fn: fn.fn, args, type: vector ? F64 : VOID, loc };
+    }
     // Numeric open flags are interpreted symbolically at the call site. The
     // O_* bit values differ between Darwin and Linux, so emit a stable mask
     // and let the target runtime select its own native constants.
@@ -2344,6 +2369,19 @@ export function lowerReflectCall(lowerer, call, access) {
     }
     if (call.questionDotToken)
         return null;
+    const reflectMember = lowerer.stdlibGlobalMember(access, "Reflect");
+    if (reflectMember === "get" || reflectMember === "set") {
+        const required = reflectMember === "get" ? 2 : 3;
+        if (call.arguments.length < required || call.arguments.length > required + 1 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`Reflect.${reflectMember} with this argument shape`, call, `use Reflect.${reflectMember}(target, key${reflectMember === "set" ? ", value" : ""}, receiver?)`);
+        }
+        const loc = locOf(call);
+        const args = call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
+        const target = call.arguments.length === required ? lowerer.declareHiddenLocal("%reflectTarget", DYN) : null;
+        const operation = { kind: "libCall", fn: reflectMember === "get" ? "dyn.reflectGet" : "dyn.reflectSet",
+            args: target ? [varRef(target.id, DYN, loc), ...args.slice(1), varRef(target.id, DYN, loc)] : args, type: reflectMember === "get" ? DYN : BOOL, loc };
+        return target ? { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: target.id, init: args[0], loc }], result: operation, type: operation.type, loc } : operation;
+    }
     if (lowerer.stdlibGlobalMember(access, "Reflect") !== "apply")
         return null;
     const loc = locOf(call);
@@ -4188,13 +4226,8 @@ function isStringDecoderTyped(lowerer, node) {
     return lowerer.checker.declarationsOf(sym).some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
         lowerer.isStdlibFile(d.getSourceFile()));
 }
-/** Method calls on StringDecoder receivers: `d.write(chunk)` decodes the
-   * complete prefix of pending+chunk and re-buffers the trailing partial
-   * sequence; `d.end()` flushes the buffered partial as its replacement
-   * chars — Node's utf8 StringDecoder exactly (SEMANTICS.md), through the
-   * interned %strdec helpers over the packed-f64 pending field. end(buf)
-   * and the rest of @types/node's surface fence per member. Null for
-   * non-decoder receivers. */
+/** StringDecoder writes preserve pending bytes; end(input) performs the
+ * final write and flushes the state. String input passes through unchanged. */
 export function lowerStringDecoderMethodCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
@@ -4204,29 +4237,37 @@ export function lowerStringDecoderMethodCall(lowerer, call, access) {
         return null;
     const name = access.name.text;
     const loc = locOf(call);
-    if (name === "write" && call.arguments.length === 1) {
-        const receiver = lowerer.lowerExpr(access.expression);
-        if (receiver.type.kind !== "record")
-            lowerer.badType(access.expression, lowerer.typeOf(access.expression));
-        let chunk = lowerBuiltinValuePreservingUndefined(lowerer, call.arguments[0]);
-        chunk = checkedOptionalBuiltinArm(lowerer, chunk, BYTES_U8) ?? chunk;
-        if (!(chunk.type.kind === "bytes" && chunk.type.elem === "u8")) {
-            lowerer.noLowering(`StringDecoder.write of '${lowerer.fmt(chunk.type)}' data`, call.arguments[0], "Buffer/Uint8Array chunks decode (narrow unions first)");
-        }
-        const helper = lowerer.strdecHelper("write", receiver.type.shapeId, loc);
-        return { kind: "call", callee: helper, args: [receiver, chunk], type: STRING, loc };
+    if ((name !== "write" && name !== "end") || call.arguments.length > 1 ||
+        (name === "write" && call.arguments.length !== 1) || call.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`StringDecoder.${name}`, call, "use write(input) or end(input?)", lowerer.checker.getSymbolAtLocation(access.name));
     }
-    if (name === "end") {
-        if (call.arguments.length !== 0) {
-            lowerer.noLowering("StringDecoder.end with a buffer argument", call, "write the buffer, then end(): d.write(buf) + d.end() is Node's own equivalence");
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        if (receiver.type.kind !== "record")
-            lowerer.badType(access.expression, lowerer.typeOf(access.expression));
-        const helper = lowerer.strdecHelper("end", receiver.type.shapeId, loc);
-        return { kind: "call", callee: helper, args: [receiver], type: STRING, loc };
+    const receiver = lowerer.lowerExpr(access.expression);
+    if (receiver.type.kind !== "record")
+        lowerer.badType(access.expression, lowerer.typeOf(access.expression));
+    if (call.arguments.length === 0) {
+        return { kind: "call", callee: lowerer.strdecHelper("end", receiver.type.shapeId, loc), args: [receiver], type: STRING, loc };
+    }
+    const node = call.arguments[0];
+    const undefinedArg = name === "end" ? lowerStaticallyUndefinedArgument(lowerer, node) : null;
+    if (undefinedArg) {
+        const saved = lowerer.declareHiddenLocal("%strdecRecv", receiver.type);
+        const result = { kind: "call", callee: lowerer.strdecHelper("end", receiver.type.shapeId, loc), args: [varRef(saved.id, receiver.type, loc)], type: STRING, loc };
+        return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: saved.id, init: receiver, loc }], result: defaultAfterUndefined(undefinedArg, result), type: STRING, loc };
     }
-    lowerer.noLowering(`StringDecoder.${name}`, call, "write(buffer) and end() are the supported StringDecoder members", lowerer.checker.getSymbolAtLocation(access.name));
+    let chunk = lowerBuiltinValuePreservingUndefined(lowerer, node);
+    if (chunk.type.kind === "string") {
+        const op = name === "end" ? "endString" : "writeString";
+        return { kind: "call", callee: lowerer.strdecHelper(op, receiver.type.shapeId, loc), args: [receiver, chunk], type: STRING, loc };
+    }
+    chunk = checkedOptionalBuiltinArm(lowerer, chunk, BYTES_U8) ?? chunk;
+    if (chunk.type.kind === "bytes" && chunk.type.elem !== "u8") {
+        chunk = { kind: "libCall", fn: "bytes.bufferSource", args: [lowerer.coerceInto(node, chunk, DYN)], type: BYTES_U8, loc };
+    }
+    if (!(chunk.type.kind === "bytes" && chunk.type.elem === "u8")) {
+        lowerer.noLowering(`StringDecoder.${name} of '${lowerer.fmt(chunk.type)}' data`, node, "pass a string or typed-array view (narrow unions first)");
+    }
+    const helper = lowerer.strdecHelper(name === "end" ? "endChunk" : "write", receiver.type.shapeId, loc);
+    return { kind: "call", callee: helper, args: [receiver, chunk], type: STRING, loc };
 }
 /** The interned %strdec helpers: write(d, chunk) returns the decoded
    * complete prefix and re-buffers the trailing partial into the pending
@@ -4264,7 +4305,7 @@ export function strdecHelper(lowerer, op, shapeId, loc) {
         { id: "s.0", name: "s", type: STRING, mutable: false },
     ];
     let body;
-    if (op === "write") {
+    if (op === "write" || op === "endChunk") {
         params.push({ localId: "chunk.0", name: "chunk", type: BYTES_U8 });
         locals.splice(1, 0, { id: "chunk.0", name: "chunk", type: BYTES_U8, mutable: false });
         body = [
@@ -4304,6 +4345,24 @@ export function strdecHelper(lowerer, op, shapeId, loc) {
             { kind: "return", value: varRef("s.0", STRING, loc), loc },
         ];
     }
+    if (op === "endString" || op === "writeString") {
+        const inputT = STRING;
+        params.push({ localId: "chunk.0", name: "chunk", type: inputT });
+        locals.push({ id: "chunk.0", name: "chunk", type: inputT, mutable: false });
+        if (op === "writeString")
+            body = [{ kind: "return", value: varRef("chunk.0", STRING, loc), loc }];
+        if (op === "endString")
+            body[body.length - 1] = { kind: "return", value: {
+                    kind: "strConcat", left: varRef("chunk.0", STRING, loc), right: varRef("s.0", STRING, loc), type: STRING, loc,
+                }, loc };
+    }
+    if (op === "endChunk") {
+        locals.push({ id: "tail.0", name: "tail", type: STRING, mutable: false });
+        body.splice(body.length - 1, 0, { kind: "varDecl", localId: "tail.0", init: { kind: "libCall", fn: "strdec.end", args: [encRead(), pendingRead()], type: STRING, loc }, loc }, { kind: "recordSet", obj: varRef("d.0", recT, loc), shapeId, field: "%pending", value: { kind: "numLit", value: 0, type: F64, loc }, loc });
+        body[body.length - 1] = { kind: "return", value: {
+                kind: "strConcat", left: varRef("s.0", STRING, loc), right: varRef("tail.0", STRING, loc), type: STRING, loc,
+            }, loc };
+    }
     lowerer.liftedFns.push({ name, params, returnType: STRING, locals, body, loc });
     return name;
 }
@@ -4400,11 +4459,11 @@ export function lowerJsonMethodCall(lowerer, call, access) {
         const optionalString = lowerOptionalStringifyRoot(lowerer, value, indent, loc);
         if (optionalString)
             return optionalString;
-        if (value.type.kind === "dyn" || isJsonStringifyDynamicType(value.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+        if (value.type.kind === "url" || value.type.kind === "dyn" || isJsonStringifyDynamicType(value.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
             // Keep the original containers live while the runtime visits them:
             // a toJSON callback can mutate a later field, and shared/cyclic
             // references must retain their identities throughout traversal.
-            const boxed = value.type.kind === "dyn" ? value : { kind: "dynFrom", value, liveRef: true, type: DYN, loc };
+            const boxed = value.type.kind === "dyn" ? value : { kind: "dynFrom", value, ...(value.type.kind === "url" ? {} : { liveRef: true }), type: DYN, loc };
             const raw = {
                 kind: "libCall", fn: "json.stringifyReplacer",
                 args: [boxed, dynUndefinedExpr(loc), { kind: "strLit", value: indent, type: STRING, loc }],
@@ -4742,8 +4801,8 @@ function cryptoEncoding(lowerer, node, use) {
 }
 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");
+    if (type.isStringLiteralType() && !["md5", "sha1", "sha224", "sha256", "sha384", "sha512"].includes(type.value.toLowerCase())) {
+        lowerer.noLowering(`${use} with algorithm '${type.value}'`, node, "md5, sha1, sha224, sha256, sha384, and sha512 are the lowered digest algorithms");
     }
     return lowerer.lowerExprExpecting(node, STRING);
 }
@@ -4762,7 +4821,19 @@ function cryptoInputBytes(lowerer, node, loc) {
     }
     lowerer.noLowering(`crypto byte input of '${lowerer.fmt(value.type)}' values`, node, "string and Buffer/Uint8Array values are supported");
 }
-function errorFirstBytesCallback(lowerer, node, api) {
+function cryptoKdfInput(lowerer, node) {
+    const loc = locOf(node);
+    const type = lowerer.mapTypeOf(lowerer.typeOf(node));
+    if (type?.kind === "string" || (type?.kind === "bytes" && type.elem === "u8"))
+        return cryptoInputBytes(lowerer, node, loc);
+    const symbol = lowerer.typeOf(node).getSymbol();
+    if (type?.kind === "bytes" || (symbol?.name === "ArrayBuffer" && lowerer.isStdlibSymbol(symbol))) {
+        const value = lowerer.coerceInto(node, lowerer.lowerExpr(node), DYN);
+        return { kind: "libCall", fn: "bytes.bufferSource", args: [value], type: BYTES_U8, loc };
+    }
+    lowerer.noLowering("crypto key derivation with this input", node, "strings, Buffers, numeric typed arrays, DataViews, and fixed-length ArrayBuffers are supported; KeyObjects are not yet lowered");
+}
+function errorFirstBytesCallback(lowerer, node, api, arrayBuffer = false) {
     let callback = lowerer.lowerExpr(node);
     if (callback.type.kind === "dyn") {
         callback = { kind: "dynCheck", value: callback, type: funcOf([DYN, DYN], VOID), loc: locOf(node) };
@@ -4784,8 +4855,8 @@ function errorFirstBytesCallback(lowerer, node, api) {
             lowerer.unsupported("SC1090", node, `${api} callback error parameters must be Error | null`);
     }
     const value = callback.type.params[1];
-    if (value !== undefined && value.kind !== "dyn" && !(value.kind === "bytes" && value.elem === "u8")) {
-        lowerer.unsupported("SC1090", node, `${api} callback result parameters must be Buffer/Uint8Array values`);
+    if (value !== undefined && value.kind !== "dyn" && (arrayBuffer || !(value.kind === "bytes" && value.elem === "u8"))) {
+        lowerer.unsupported("SC1090", node, `${api} callback result parameters must be ${arrayBuffer ? "ArrayBuffer" : "Buffer/Uint8Array"} values`);
     }
     return voidizedCallback(lowerer, callback, locOf(node));
 }
@@ -4833,6 +4904,31 @@ export function lowerCryptoModuleCall(lowerer, expr, bi, loc) {
             loc,
         };
     }
+    if (bi.member === "hkdf" || bi.member === "hkdfSync") {
+        const async = bi.member === "hkdf";
+        if (args.length !== (async ? 6 : 5))
+            lowerer.noLowering(`crypto.${bi.member} with ${args.length} arguments`, expr);
+        const values = [
+            cryptoAlgorithm(lowerer, args[0], `crypto.${bi.member}`),
+            cryptoKdfInput(lowerer, args[1]), cryptoKdfInput(lowerer, args[2]), cryptoKdfInput(lowerer, args[3]),
+            lowerer.lowerExprExpecting(args[4], F64),
+        ];
+        if (async)
+            values.push(errorFirstBytesCallback(lowerer, args[5], "crypto.hkdf", true));
+        return { kind: "libCall", fn: async ? "crypto.hkdfCb" : "crypto.hkdf", args: values, type: async ? VOID : DYN, loc };
+    }
+    if (bi.member === "scrypt" || bi.member === "scryptSync") {
+        const async = bi.member === "scrypt";
+        const minimum = async ? 4 : 3;
+        if (args.length < minimum || args.length > minimum + 1)
+            lowerer.noLowering(`crypto.${bi.member} with ${args.length} arguments`, expr);
+        const values = [cryptoKdfInput(lowerer, args[0]), cryptoKdfInput(lowerer, args[1]), lowerer.lowerExprExpecting(args[2], F64)];
+        const options = args.length > minimum ? args[3] : undefined;
+        values.push(options ? lowerer.coerceInto(options, lowerer.lowerExpr(options), DYN) : dynUndefinedExpr(loc));
+        if (async)
+            values.push(errorFirstBytesCallback(lowerer, args[args.length - 1], "crypto.scrypt"));
+        return { kind: "libCall", fn: async ? "crypto.scryptCb" : "crypto.scrypt", args: values, type: async ? VOID : BYTES_U8, 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");
@@ -4940,7 +5036,7 @@ export function lowerCryptoModuleCall(lowerer, expr, bi, loc) {
         loc,
     };
 }
-/** Method calls on URL-typed receivers: `u.toString()` is Node's href
+/** Method calls on URL-typed receivers: `u.toString()` and `u.toJSON()` are Node's href
    * serialization (the href getter's libCall). Everything else the lib
    * declares fences member-qualified. Null for non-URL receivers. */
 export function lowerUrlMethodCall(lowerer, call, access) {
@@ -4951,11 +5047,11 @@ export function lowerUrlMethodCall(lowerer, call, access) {
     if (!lowerer.isStdlibMember(access))
         return null;
     const name = access.name.text;
-    if (name === "toString" && call.arguments.length === 0) {
+    if ((name === "toString" || name === "toJSON") && call.arguments.length === 0) {
         const receiver = lowerer.lowerExpr(access.expression);
         return { kind: "libCall", fn: "url.href", args: [receiver], type: STRING, loc: locOf(call) };
     }
-    lowerer.noLowering(`URL.${name}`, call, "protocol, origin, username, password, pathname, href, host, hostname, port, search, hash, searchParams, and toString() are the supported URL members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`URL.${name}`, call, "protocol, origin, username, password, pathname, href, host, hostname, port, search, hash, searchParams, toString(), and toJSON() are the supported URL members", lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** `new URLSearchParams(init?)` — the WHATWG constructor's lowered init
    * shapes: omitted / literal `undefined` (empty list), a string (parsed,
@@ -5329,18 +5425,21 @@ export function lowerFileHandleMethodCall(lowerer, call, access) {
     const loc = locOf(call);
     const receiver = () => lowerer.lowerExprExpecting(access.expression, FILEHANDLE_T);
     const promise = (inner) => ({ kind: "promise", inner });
-    const num = (node, dflt) => {
+    const num = (node, dflt, lowered) => {
         const defaultValue = { kind: "numLit", value: dflt, type: F64, loc };
-        if (!node)
+        if (!node && !lowered)
             return { value: defaultValue, defaulted: boolLit(true, loc) };
-        const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, node);
+        if (lowered && isUnitType(lowered.type)) {
+            return { value: defaultAfterUndefined(lowered, defaultValue), defaulted: boolLit(true, loc) };
+        }
+        const undefinedArg = !lowered && node ? lowerStaticallyUndefinedArgument(lowerer, node) : null;
         if (undefinedArg) {
             return { value: defaultAfterUndefined(undefinedArg, defaultValue), defaulted: boolLit(true, loc) };
         }
-        if ((lowerer.typeOf(node).flags & ts.TypeFlags.Null) !== 0) {
+        if (!lowered && node && (lowerer.typeOf(node).flags & ts.TypeFlags.Null) !== 0) {
             return { value: defaultAfterUndefined(lowerer.lowerExpr(node), defaultValue), defaulted: boolLit(true, loc) };
         }
-        const value = lowerer.lowerExpr(node);
+        const value = lowered ?? lowerer.lowerExpr(node);
         if (value.type.kind === "union") {
             const def = lowerer.unions.get(value.type.unionId);
             const units = def?.arms.filter(isUnitType) ?? [];
@@ -5386,7 +5485,7 @@ export function lowerFileHandleMethodCall(lowerer, call, access) {
                 };
             }
         }
-        return { value: lowerer.coerceInto(node, value, F64), defaulted: boolLit(false, loc) };
+        return { value: lowerer.coerceInto(node ?? call, value, F64), defaulted: boolLit(false, loc) };
     };
     const utf8 = (node) => {
         const dflt = { kind: "strLit", value: "utf8", type: STRING, loc };
@@ -5401,6 +5500,30 @@ export function lowerFileHandleMethodCall(lowerer, call, access) {
         }
         return lowerBuiltinOptionalDefault(lowerer, node, STRING, dflt, true);
     };
+    if (name === "sync" || name === "datasync") {
+        if (call.arguments.length !== 0)
+            lowerer.noLowering(`FileHandle.${name} with arguments`, call);
+        return { kind: "libCall", fn: name === "sync" ? "fileHandle.sync" : "fileHandle.datasync", args: [receiver()], type: promise(VOID), loc };
+    }
+    if (name === "truncate" || name === "chmod") {
+        if (call.arguments.length > 1 || (name === "chmod" && call.arguments.length !== 1))
+            lowerer.noLowering(`FileHandle.${name} with ${call.arguments.length} arguments`, call);
+        return {
+            kind: "libCall", fn: name === "truncate" ? "fileHandle.truncate" : "fileHandle.chmod",
+            args: [receiver(), num(call.arguments[0], 0).value], type: promise(VOID), loc,
+        };
+    }
+    if (name === "readv" || name === "writev") {
+        if (call.arguments.length < 1 || call.arguments.length > 2)
+            lowerer.noLowering(`FileHandle.${name} with ${call.arguments.length} arguments`, call);
+        const type = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (type?.kind !== "promise" || type.inner.kind !== "record")
+            lowerer.badType(call, lowerer.typeOf(call));
+        return {
+            kind: "libCall", fn: name === "readv" ? "fileHandle.readv" : "fileHandle.writev",
+            args: [receiver(), lowerer.lowerExprExpecting(call.arguments[0], arrayOf(BYTES_U8)), num(call.arguments[1], -1).value], type, loc,
+        };
+    }
     if (name === "close" || name === "stat") {
         if (call.arguments.length !== 0)
             lowerer.noLowering(`FileHandle.${name} with arguments`, call);
@@ -5458,6 +5581,65 @@ export function lowerFileHandleMethodCall(lowerer, call, access) {
         }
         lowerer.noLowering(`FileHandle.${name} of '${dataT ? lowerer.fmt(dataT) : lowerer.checker.typeToString(lowerer.typeOf(dataNode))}' data`, dataNode, "string and Uint8Array data are supported");
     }
+    if (name === "read" || name === "write") {
+        const firstNode = call.arguments[0];
+        const firstT = firstNode ? lowerer.mapTypeOf(lowerer.typeOf(firstNode)) : undefined;
+        const secondT = call.arguments[1] ? lowerer.mapTypeOf(lowerer.typeOf(call.arguments[1])) : undefined;
+        const readOptions = name === "read" && (!firstNode || firstT?.kind === "record" || (firstT && isUnitType(firstT)));
+        const bufferOptions = firstT?.kind === "bytes" && firstT.elem === "u8" && secondT?.kind === "record";
+        if (readOptions || bufferOptions) {
+            if (call.arguments.length > (bufferOptions ? 2 : 1))
+                lowerer.noLowering(`FileHandle.${name} options with extra arguments`, call);
+            const type = lowerer.mapTypeOf(lowerer.typeOf(call));
+            if (type?.kind !== "promise" || type.inner.kind !== "record")
+                lowerer.badType(call, lowerer.typeOf(call));
+            const stmts = [];
+            const stage = (value, label) => {
+                const local = lowerer.declareHiddenLocal(label, value.type);
+                stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc });
+                return varRef(local.id, local.type, loc);
+            };
+            const handle = stage(receiver(), "%fhWindowReceiver");
+            let buffer = bufferOptions ? stage(lowerer.lowerExprExpecting(firstNode, BYTES_U8), "%fhWindowBuffer") : undefined;
+            const optionsNode = bufferOptions ? call.arguments[1] : firstNode;
+            const options = optionsNode ? stage(lowerer.lowerExpr(optionsNode), "%fhWindowOptions") : undefined;
+            const field = (key) => {
+                if (options?.type.kind !== "record")
+                    return undefined;
+                const fields = lowerer.shapes.get(options.type.shapeId)?.fields;
+                const getter = fields?.find((f) => f.name === `%get:${key}`);
+                if (getter?.type.kind === "func") {
+                    const callee = { kind: "recordGet", obj: options, shapeId: options.type.shapeId, field: getter.name, type: getter.type, loc };
+                    return { kind: "callValue", callee, args: [], type: getter.type.ret, loc };
+                }
+                const member = fields?.find((f) => f.name === key);
+                return member ? { kind: "recordGet", obj: options, shapeId: options.type.shapeId, field: key, type: member.type, loc } : undefined;
+            };
+            if (!buffer) {
+                const supplied = field("buffer");
+                const fresh = { kind: "bytesNew", source: numLit(16384, loc), type: BYTES_U8, loc };
+                if (!supplied || isUnitType(supplied.type))
+                    buffer = supplied ? defaultAfterUndefined(supplied, fresh) : fresh;
+                else if (supplied.type.kind === "union") {
+                    const arms = lowerer.unions.get(supplied.type.unionId)?.arms;
+                    if (!arms?.every((arm) => typeEquals(arm, BYTES_U8) || isUnitType(arm)))
+                        lowerer.noLowering("FileHandle.read with this buffer type", call);
+                    buffer = { kind: "nullish", left: supplied, right: fresh, type: BYTES_U8, loc };
+                }
+                else
+                    buffer = lowerer.coerceInto(call, supplied, BYTES_U8);
+                buffer = stage(buffer, "%fhWindowBuffer");
+            }
+            const offset = num(undefined, 0, field("offset"));
+            const length = num(undefined, -1, field("length"));
+            const position = num(undefined, -1, field("position"));
+            const result = {
+                kind: "libCall", fn: name === "read" ? "fileHandle.read" : "fileHandle.writeBytes",
+                args: [handle, buffer, offset.value, length.value, position.value, length.defaulted], type, loc,
+            };
+            return { kind: "seqExpr", stmts, result, type, loc };
+        }
+    }
     if (name === "read") {
         if (call.arguments.length < 1 || call.arguments.length > 4) {
             lowerer.noLowering(`FileHandle.read with ${call.arguments.length} arguments`, call, "use read(buffer[, offset[, length[, position]]])");
@@ -5516,7 +5698,7 @@ export function lowerFileHandleMethodCall(lowerer, call, access) {
         }
         lowerer.noLowering(`FileHandle.write of '${dataT ? lowerer.fmt(dataT) : lowerer.checker.typeToString(lowerer.typeOf(dataNode))}' data`, dataNode, "string and Uint8Array data are supported");
     }
-    lowerer.noLowering(`FileHandle.${name}`, call, "fd, close(), read(), write(), readFile(), writeFile(), appendFile(), and stat() are the supported FileHandle members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`FileHandle.${name}`, call, "fd, close(), read(), write(), readv(), writev(), readFile(), writeFile(), appendFile(), stat(), sync(), datasync(), truncate(), and chmod() are the supported FileHandle members", lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** Method calls on Stats-typed receivers: isFile()/isDirectory()/
    * isSymbolicLink() are pure reads on the stat snapshot (a followed
@@ -5670,6 +5852,21 @@ export function lowerAtomicsCall(lowerer, call, access) {
 export function lowerBuiltinExtraProperty(lowerer, expr) {
     if (expr.questionDotToken && !lowerer.chainHandled.has(expr))
         return null;
+    const codec = storedTextCodecClassOf(lowerer, expr.expression);
+    if (codec && lowerer.isStdlibMember(expr) && ["encoding", "fatal", "ignoreBOM"].includes(expr.name.text)) {
+        const receiver = lowerer.lowerExpr(expr.expression);
+        if (receiver.type.kind !== "record")
+            lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
+        const loc = locOf(expr);
+        if (codec === "TextEncoder" && expr.name.text === "encoding") {
+            return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: receiver, loc }], result: strLit("utf-8", loc), type: STRING, loc };
+        }
+        if (codec === "TextDecoder") {
+            const field = expr.name.text === "encoding" ? "%TextDecoder" : `%${expr.name.text}`;
+            const value = { kind: "recordGet", obj: receiver, shapeId: receiver.type.shapeId, field, type: expr.name.text === "encoding" ? F64 : BOOL, loc };
+            return expr.name.text === "encoding" ? { kind: "libCall", fn: "text.decoderName", args: [value], type: STRING, loc } : value;
+        }
+    }
     // decoder.encoding on a StringDecoder-typed receiver: the record's
     // hidden canonical-name field (construction folded the aliases —
     // exactly what Node's normalized `.encoding` answers).
@@ -5680,6 +5877,15 @@ 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 === "record" && ["read", "written"].includes(expr.name.text) && lowerer.isStdlibMember(expr)) {
+        const receiver = lowerer.lowerExpr(expr.expression);
+        if (receiver.type.kind === "record") {
+            const fields = lowerer.shapes.get(receiver.type.shapeId)?.fields;
+            if (fields?.length === 2 && fields.every((field) => ["read", "written"].includes(field.name) && field.type.kind === "f64")) {
+                return { kind: "recordGet", obj: receiver, shapeId: receiver.type.shapeId, field: expr.name.text, type: F64, loc: locOf(expr) };
+            }
+        }
+    }
     if (kind !== "stats" && kind !== "fileHandle" && kind !== "spawnRes" && kind !== "child" && kind !== "childWriter")
         return null;
     if (kind === "child" ? !isChildSurfaceMember(lowerer, expr) : !lowerer.isStdlibMember(expr))
@@ -5896,14 +6102,15 @@ export function lowerChildMethodCall(lowerer, call, access) {
                 lowerer.checkedCallbackParams.add(param);
         }
         const cb = lowerer.lowerExpr(call.arguments[1]);
-        if (cb.type.kind === "func" && cb.type.rest) {
-            if (!canBoxFuncIntoDyn(cb.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-                lowerer.noLowering("child event rest listeners with non-representable parameters", call.arguments[1]);
+        if (isJsSourceFile(listenerNode.getSourceFile()) && cb.type.kind === "dyn" ||
+            cb.type.kind === "func" && (cb.type.rest || isJsSourceFile(listenerNode.getSourceFile()) && cb.type.params.some((param) => param.kind === "dyn"))) {
+            if (cb.type.kind !== "dyn" && !canBoxFuncIntoDyn(cb.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                lowerer.noLowering("child event listeners with non-representable parameters", call.arguments[1]);
             }
             return {
                 kind: "libCall", fn: "child.onDyn",
                 args: [receiver, { kind: "strLit", value: event, type: STRING, loc },
-                    { kind: "dynFrom", value: cb, type: DYN, loc }],
+                    cb.type.kind === "dyn" ? cb : { kind: "dynFrom", value: cb, type: DYN, loc }],
                 type: VOID, loc,
             };
         }
@@ -6286,7 +6493,8 @@ export function lowerErrorCodeProperty(lowerer, expr) {
         return null;
     if (!lowerer.isStdlibMember(expr))
         return null;
-    const receiver = lowerer.lowerExpr(expr.expression);
+    const rawReceiver = lowerer.lowerExpr(expr.expression);
+    const receiver = rawReceiver.type.kind === "dyn" ? lowerer.coerceInto(expr.expression, rawReceiver, recvT) : rawReceiver;
     return {
         kind: "libCall",
         fn: expr.name.text === "stack" ? "error.stack" : expr.name.text === "cause" ? "error.cause" : "error.code",
@@ -6986,6 +7194,19 @@ export function lowerProcessEnvGet(lowerer, expr) {
     const key = { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) };
     return { kind: "libCall", fn: "process.envGet", args: [key], type: lowerer.envValueType(), loc };
 }
+function lowerProcessLoadEnvFile(lowerer, call) {
+    if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering("process.loadEnvFile with spread or extra arguments", call);
+    }
+    const loc = locOf(call);
+    const path = call.arguments[0] ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+        : { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
+    const load = { kind: "libCall", fn: "process.loadEnvFile", args: [path], type: VOID, loc };
+    if (ts.isExpressionStatement(call.parent))
+        return load;
+    return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: load, loc }],
+        result: { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc }, type: DYN, loc };
+}
 /** `process.exit(code)` / `process.cwd()` → libCall. The fallback
    * declaration makes exit's code required; @types/node declares it
    * optional. A bare `process.exit()` uses the current exitCode, or zero
@@ -7003,6 +7224,8 @@ export function lowerProcessMethodCall(lowerer, call, access) {
         }
     }
     const directProcessMember = lowerer.stdlibGlobalMember(access, "process");
+    if (directProcessMember === "loadEnvFile")
+        return lowerProcessLoadEnvFile(lowerer, call);
     if (directProcessMember === "hrtime") {
         if (call.arguments.some(ts.isSpreadElement))
             lowerer.noLowering("process.hrtime with spread arguments", call);
@@ -7991,6 +8214,18 @@ export function lowerTextCodecCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
     const member = access.name.text;
+    if (member === "encodeInto" && storedTextCodecClassOf(lowerer, access.expression) === "TextEncoder" && lowerer.isStdlibMember(access)) {
+        if (call.arguments.length !== 2 || call.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering("TextEncoder.encodeInto with this argument shape", call);
+        const loc = locOf(call);
+        const receiver = lowerer.lowerExpr(access.expression);
+        const result = { kind: "libCall", fn: "text.encodeInto", args: call.arguments.map((arg) => lowerer.lowerExprExpecting(stripTypeCasts(arg), DYN)), type: DYN, loc };
+        const type = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (!type)
+            lowerer.badType(call, lowerer.typeOf(call));
+        const checked = lowerer.coerceInto(call, result, type);
+        return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: receiver, loc }], result: checked, type, loc };
+    }
     if (member !== "decode" && member !== "encode")
         return null;
     const info = directTextCodecCtorOf(lowerer, access.expression);
@@ -8294,9 +8529,14 @@ export function lowerPromiseStaticCall(lowerer, call, access) {
                     lowerer.diags.splice(diagsBefore);
                 }
             }
+            if (!lowerer.dynamic && isJsSourceFile(call.getSourceFile()) && elems.every((entry) => lowerer.dynConvertible(entry.type))) {
+                return checkedPromiseAll(lowerer, { kind: "arrayLit", elems: elems.map((entry) => lowerer.coerceToExpected(entry, DYN)), type: arrayOf(DYN), loc }, loc);
+            }
             lowerer.noLowering("Promise.all over this argument shape", argNode, "the entries must share ONE promise type — Promise.all([p, q]) lowers when p and q are the same Promise<T>");
         }
         const entries = lowerer.lowerExpr(argNode);
+        if (!lowerer.dynamic && isJsSourceFile(call.getSourceFile()) && entries.type.kind === "dyn")
+            return checkedPromiseAll(lowerer, entries, loc);
         // A NON-literal island argument (`Promise.all(plugins.map((p) =>
         // loadPlugin(p)))` — the loadPlugins shape, where the checker
         // spells `any[]`): the ENGINE's own Promise.all runs over the