@scriptc/compiler 0.2.1 → 0.2.3

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
@@ -20,6 +21,7 @@ import { builtinModuleFnOf, FS_READDIR_DOCUMENTED_OPTIONS, FS_WATCH_DOCUMENTED_O
 import { lowerAbsenceProbe } from "./lower-exprs.js";
 import { conditionalSpreadOf, lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, lowerStringSearchArgument } from "./optional-arguments.js";
 import { HTTP2_CONSTANTS } from "./http2-constants.js";
 import { CRYPTO_CIPHERS, CRYPTO_CONSTANTS, CRYPTO_CURVES, CRYPTO_HASHES } from "./crypto-tables.js";
@@ -44,6 +46,67 @@ function optionalStringTags(lowerer, type) {
     const undefinedTag = lowerer.armTag(type.unionId, UNDEFINED_T);
     return stringTag >= 0 && undefinedTag >= 0 ? { stringTag, undefinedTag } : null;
 }
+/** URL component assignment captures its receiver and RHS once, and yields
+ * the original RHS after the setter performs string conversion. */
+export function lowerUrlAssignment(lowerer, expr) {
+    let target = expr.left;
+    while (ts.isParenthesizedExpression(target))
+        target = target.expression;
+    if ((!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) || target.questionDotToken)
+        return null;
+    const receiverType = lowerer.typeOf(target.expression);
+    const native = lowerer.mapTypeOf(receiverType)?.kind === "url";
+    if (!native && !(receiverType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)))
+        return null;
+    const receiver = native ? lowerer.lowerExpr(target.expression) : tryLowerExpression(lowerer, target.expression);
+    if (!receiver || receiver.type.kind !== "url")
+        return null;
+    const name = ts.isPropertyAccessExpression(target) ? target.name.text : lowerer.foldedStringKeyOf(target.argumentExpression);
+    const getters = {
+        href: "url.href", pathname: "url.pathname", search: "url.search", hash: "url.hash",
+        protocol: "url.protocol", username: "url.username", password: "url.password",
+        host: "url.host", hostname: "url.hostname", port: "url.port",
+    };
+    if (name === null || name === undefined || !Object.hasOwn(getters, name)) {
+        lowerer.unsupported("SC1090", target, "URL assignments to read-only members or runtime property keys");
+    }
+    const op = expr.operatorToken.kind;
+    if (op !== ts.SyntaxKind.EqualsToken && op !== ts.SyntaxKind.PlusEqualsToken) {
+        lowerer.unsupported("SC1090", expr, "URL setter assignment operators beyond = and +=");
+    }
+    const loc = locOf(expr);
+    const recv = lowerer.declareHiddenLocal("%urlReceiver", receiver.type);
+    const recvRef = varRef(recv.id, receiver.type, loc);
+    const stmts = [{ kind: "varDecl", localId: recv.id, init: receiver, loc }];
+    let prior = null;
+    if (op === ts.SyntaxKind.PlusEqualsToken) {
+        const old = lowerer.declareHiddenLocal("%urlOld", STRING);
+        const fn = getters[name];
+        stmts.push({ kind: "varDecl", localId: old.id, init: { kind: "libCall", fn, args: [recvRef], type: STRING, loc }, loc });
+        prior = varRef(old.id, STRING, loc);
+    }
+    const raw = lowerer.lowerExpr(expr.right);
+    if (prior && raw.type.kind !== "string" && raw.type.kind !== "f64" && raw.type.kind !== "bool" && raw.type.kind !== "bigint" && !isUnitType(raw.type)) {
+        lowerer.unsupported("SC1090", expr.right, "URL += operands requiring object-to-primitive conversion (assign an explicit string)");
+    }
+    const value = lowerer.declareHiddenLocal("%urlValue", raw.type);
+    stmts.push({ kind: "varDecl", localId: value.id, init: raw, loc });
+    const valueRef = varRef(value.id, raw.type, loc);
+    let result = valueRef;
+    let assigned = valueRef;
+    if (prior) {
+        const text = raw.type.kind === "string" ? valueRef : {
+            kind: "libCall", fn: "dyn.toStringCoerce", args: [lowerer.coerceInto(expr.right, valueRef, DYN)], type: STRING, loc,
+        };
+        const joined = lowerer.declareHiddenLocal("%urlJoined", STRING);
+        stmts.push({ kind: "varDecl", localId: joined.id, init: { kind: "strConcat", left: prior, right: text, type: STRING, loc }, loc });
+        result = varRef(joined.id, STRING, loc);
+        assigned = result;
+    }
+    const checked = !prior && raw.type.kind !== "string";
+    stmts.push({ kind: "exprStmt", expr: { kind: "libCall", fn: checked ? "url.setChecked" : "url.set", args: [recvRef, strLit(name, loc), checked ? lowerer.coerceInto(expr.right, valueRef, DYN) : assigned], type: VOID, loc }, loc });
+    return { kind: "seqExpr", stmts, result, type: result.type, loc };
+}
 /** 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
@@ -1140,17 +1203,26 @@ function lowerFsSyncBufferWindow(lowerer, expr, loc, fn, source, supported) {
  * Node's exact ERR_INVALID_ARG_TYPE. The argument crosses as a dyn
  * value so the runtime renders the Received tail. Null when this is
  * not that call (the table fence stays for other shapes). */
+function lowerFsTimestampValue(lowerer, node, loc) {
+    if (!node)
+        return dynUndefinedExpr(loc);
+    const box = (value) => {
+        if (value.type.kind === "date") {
+            const milliseconds = { kind: "libCall", fn: "date.getTime", args: [value], type: F64, loc };
+            return { kind: "libCall", fn: "date.nativeNew", args: [{ kind: "dynArrLit", elems: [
+                            { kind: "dynFrom", value: milliseconds, type: DYN, loc },
+                        ], type: DYN, loc }], type: DYN, loc };
+        }
+        return lowerer.coerceInto(node, value, DYN);
+    };
+    return box(lowerer.lowerExpr(node));
+}
 export function lowerFsToUnixTimestampCall(lowerer, expr, bi, loc) {
     if (bi.module !== "fs" || bi.member !== "_toUnixTimestamp")
         return null;
     if (expr.arguments.length !== 1 || ts.isSpreadElement(expr.arguments[0]))
         return null;
-    const raw = lowerer.lowerExpr(expr.arguments[0]);
-    if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
-        const arg = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
-        return { kind: "libCall", fn: "fs.toUnixTimestamp", args: [arg], type: F64, loc };
-    }
-    return null;
+    return { kind: "libCall", fn: "fs.toUnixTimestamp", args: [lowerFsTimestampValue(lowerer, expr.arguments[0], loc)], type: F64, loc };
 }
 /** The fs validation-ladder spoke (checked-dynamic lane, JS sources
  * only — TypeScript keeps its compile fences): implemented-namespace
@@ -1414,12 +1486,76 @@ function lowerZlibModuleCall(lowerer, expr, bi, loc) {
 }
 export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     const name = expr.expression.getText();
+    if (bi.module === "util/types") {
+        if (expr.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering(`${name} with spread arguments`, expr);
+        const input = expr.arguments[0] ? lowerer.lowerExprExpecting(expr.arguments[0], DYN) : dynUndefinedExpr(loc);
+        const saved = lowerer.declareHiddenLocal("%utilTypeInput", DYN);
+        return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: saved.id, init: input, loc },
+                ...expr.arguments.slice(1).map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc }))],
+            result: { kind: "libCall", fn: "util.typeIs", args: [varRef(saved.id, DYN, loc), strLit(bi.member, loc)], type: BOOL, loc }, type: BOOL, loc };
+    }
+    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 };
+        const timestamp = ["utimes", "futimes", "lutimes"].includes(bi.member);
+        const args = { kind: "dynArrLit", elems: expr.arguments.map((arg, index) => timestamp && (index === 1 || index === 2)
+                ? lowerFsTimestampValue(lowerer, arg, loc) : 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" && ["linkSync", "symlinkSync", "readlinkSync", "statfsSync"].includes(bi.member)) ||
+        (bi.module === "fs/promises" && ["link", "symlink", "readlink", "statfs"].includes(bi.member))) {
+        const symbolic = bi.member === "symlinkSync" || bi.member === "symlink";
+        const reading = bi.member === "readlinkSync" || bi.member === "readlink";
+        const arity = symbolic ? 3 : 2;
+        if (expr.arguments.length > arity || expr.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering(`${name} with this argument shape`, expr);
+        const args = Array.from({ length: arity }, (_, index) => expr.arguments[index]
+            ? lowerer.lowerExprExpecting(expr.arguments[index], DYN) : dynUndefinedExpr(loc));
+        if (reading) {
+            const promise = bi.module === "fs/promises";
+            const result = lowerer.mapTypeOf(lowerer.typeOf(expr)) ?? fn.result;
+            const inner = result.kind === "promise" ? result.inner : result;
+            const bytes = inner.kind === "bytes";
+            const text = inner.kind === "string";
+            const selected = promise ? bytes ? "fsp.readlinkBuffer" : text ? "fsp.readlinkStr" : "fsp.readlink"
+                : bytes ? "fs.readlinkSyncBuffer" : text ? "fs.readlinkSyncStr" : "fs.readlinkSync";
+            const valueType = bytes ? BYTES_U8 : text ? STRING : DYN;
+            return { kind: "libCall", fn: selected, args, type: promise ? { kind: "promise", inner: valueType } : valueType, loc };
+        }
+        return { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
+    }
+    if ((bi.module === "fs" && ["utimesSync", "futimesSync", "lutimesSync"].includes(bi.member)) ||
+        (bi.module === "fs/promises" && ["utimes", "lutimes"].includes(bi.member))) {
+        if (expr.arguments.length > 3 || expr.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering(`${name} with this argument shape`, expr);
+        const path = expr.arguments[0] ? lowerer.lowerExprExpecting(expr.arguments[0], DYN) : dynUndefinedExpr(loc);
+        return { kind: "libCall", fn: fn.fn, args: [path, lowerFsTimestampValue(lowerer, expr.arguments[1], loc), lowerFsTimestampValue(lowerer, expr.arguments[2], loc)], type: fn.result, 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.
@@ -2221,29 +2357,28 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     }
     const required = fn.params.length - (fn.defaults?.length ?? 0);
     const hasSpread = expr.arguments.some(ts.isSpreadElement);
-    if (!hasSpread && bi.module === "url" && bi.member === "pathToFileURL" && expr.arguments.length === 2) {
-        let options = expr.arguments[1];
-        while (ts.isParenthesizedExpression(options) || ts.isSatisfiesExpression(options))
-            options = options.expression;
-        if (!ts.isObjectLiteralExpression(options) || options.properties.length > 1) {
-            lowerer.noLowering("pathToFileURL with these options", options, "use a literal { windows: boolean } options object");
-        }
-        let windowsNode = null;
-        const property = options.properties[0];
-        if (property) {
-            if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
-                (!ts.isIdentifier(property.name) && !ts.isStringLiteral(property.name)) || property.name.text !== "windows") {
-                lowerer.noLowering("pathToFileURL with these options", property, "use a literal { windows: boolean } options object");
+    if (bi.module === "url" && ["fileURLToPath", "fileURLToPathBuffer", "pathToFileURL"].includes(bi.member)) {
+        if (hasSpread || expr.arguments.length > 2) {
+            lowerer.noLowering(`${bi.member} with these arguments`, expr, "pass a path and optional options object directly");
+        }
+        // Keep the established typed one-argument paths free of boxing. The
+        // checked variants preserve each converter's validation/getter order.
+        if (expr.arguments.length === 1 && bi.member !== "fileURLToPathBuffer") {
+            const arg = lowerer.lowerExpr(expr.arguments[0]);
+            if (bi.member === "fileURLToPath") {
+                if (arg.type.kind === "url")
+                    return { kind: "libCall", fn: "url.fileURLToPathUrl", args: [arg], type: STRING, loc };
+                if (arg.type.kind === "string")
+                    return { kind: "libCall", fn: "url.fileURLToPathStr", args: [arg], type: STRING, loc };
             }
-            windowsNode = ts.isPropertyAssignment(property) ? property.initializer : property.name;
+            else if (arg.type.kind === "string") {
+                return { kind: "libCall", fn: lowerer.targetPlatform === "win32" ? "url.pathToFileURLWin32" : "url.pathToFileURL", args: [arg], type: fn.result, loc };
+            }
+            return { kind: "libCall", fn: fn.fn, args: [lowerer.coerceToExpected(arg, DYN), dynUndefinedExpr(loc)], type: fn.result, loc };
         }
-        const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-        const defaultWindows = { kind: "boolLit", value: lowerer.targetPlatform === "win32", type: BOOL, loc };
-        const windows = windowsNode ? lowerOptionalArgument(lowerer, windowsNode, BOOL, defaultWindows) : defaultWindows;
-        return { kind: "libCall", fn: "url.pathToFileURLPlatform", args: [path, windows], type: fn.result, loc };
-    }
-    if (hasSpread && bi.module === "url" && bi.member === "fileURLToPath") {
-        lowerer.noLowering("fileURLToPath with spread arguments", expr, "call fileURLToPath(value) directly so the URL-or-string overload remains statically visible");
+        const args = [0, 1].map((index) => expr.arguments[index]
+            ? lowerer.lowerExprExpecting(expr.arguments[index], DYN) : dynUndefinedExpr(loc));
+        return { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
     }
     if (hasSpread &&
         ((bi.module === "fs" && bi.member === "readFileSync") ||
@@ -2255,22 +2390,6 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
             ? `pass the encoding: ${bi.member}(path, "utf8") — Buffer reads and options objects have no lowering`
             : `the supported form takes ${fn.params.length} argument${fn.params.length === 1 ? "" : "s"} (no options objects)`);
     }
-    if (!hasSpread && bi.module === "url" && bi.member === "fileURLToPath") {
-        // Node accepts a URL value or a URL string — one libFn per receiver
-        // form, picked by the argument's static type. Unions (URL |
-        // undefined, ...) must narrow first, like everywhere else.
-        const argNode = expr.arguments[0];
-        const arg = lowerer.lowerExpr(argNode);
-        if (arg.type.kind === "dyn")
-            return { kind: "libCall", fn: "url.fileURLToPathChecked", args: [arg], type: STRING, loc };
-        if (arg.type.kind === "url") {
-            return { kind: "libCall", fn: "url.fileURLToPathUrl", args: [arg], type: STRING, loc };
-        }
-        if (arg.type.kind === "string") {
-            return { kind: "libCall", fn: "url.fileURLToPathStr", args: [arg], type: STRING, loc };
-        }
-        lowerer.noLowering(`fileURLToPath of '${lowerer.fmt(arg.type)}' values`, argNode, "pass a URL value or a URL string (narrow unions first)");
-    }
     if (!hasSpread && ((bi.module === "fs" && bi.member === "readFileSync") ||
         (bi.module === "fs/promises" && bi.member === "readFile"))) {
         // The runtime reads utf8 unconditionally; any other encoding would
@@ -2344,6 +2463,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);
@@ -3491,6 +3623,11 @@ export function registerBuiltinCallableAlias(lowerer, nameNode, init) {
         : lowerer.builtinImportOf(targetExpr);
     if (!target || !builtinModuleFnOf(lowerer, target.module, target.member))
         return false;
+    // These checked native functions retain a runtime slot in JavaScript so
+    // aliases can escape without narrowing their arguments to string.
+    if (isJsSourceFile(nameNode.getSourceFile()) && target.module === "util" &&
+        ["stripVTControlCharacters", "toUSVString", "isDeepStrictEqual", "styleText"].includes(target.member))
+        return false;
     if (lowerer.checker.getCallSignatures(lowerer.typeOf(nameNode)).length === 0)
         return false;
     const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
@@ -4188,13 +4325,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 +4336,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 };
+    }
+    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 };
     }
-    lowerer.noLowering(`StringDecoder.${name}`, call, "write(buffer) and end() are the supported StringDecoder members", lowerer.checker.getSymbolAtLocation(access.name));
+    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 +4404,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 +4444,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 +4558,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 +4900,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 +4920,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 +4954,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 +5003,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 +5135,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 +5146,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 +5524,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 +5584,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 +5599,35 @@ 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 === "utimes") {
+        if (call.arguments.length !== 2 || call.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering("FileHandle.utimes with this argument shape", call);
+        return { kind: "libCall", fn: "fileHandle.utimes", args: [receiver(), lowerFsTimestampValue(lowerer, call.arguments[0], loc), lowerFsTimestampValue(lowerer, call.arguments[1], loc)], 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 +5685,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 +5802,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 +5956,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 +5981,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 +6206,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 +6597,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 +7298,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 +7328,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 +8318,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 +8633,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