@scriptc/compiler 0.2.0 → 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
@@ -7,6 +8,7 @@ import { InternalCompilerError } from "../../errors.js";
 import { builtinModules } from "node:module";
 import { dirname, isAbsolute, resolve } from "node:path";
 import * as ts from "../ts7/adapter.js";
+import { lowerCheckedPredicateValue } from "./lower-builtin-values.js";
 import { PoisonError, dynUndefinedExpr, ladderFenceExpr, nodeThrowExpr, own } from "./lowerer.js";
 import { canonicalBuiltinModule, isCreateRequireBinding7, isJsSourceFile, isNodeEsmFile, locOf, npmStaticDepSf7, requireSpecOf, resolveImport } from "../program.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
@@ -480,7 +482,7 @@ export function createRequireProgramModuleOf(lowerer, expr) {
     const cr = createRequireSpecOf(lowerer, call);
     if (cr === null || cr.spec === null || canonicalBuiltinModule(cr.spec) !== null)
         return null;
-    const dep = resolveImport(lowerer.program, cr.baseFile, cr.spec) ??
+    const dep = resolveImport(lowerer.program, cr.baseFile, cr.spec, "require") ??
         npmStaticDepSf7(lowerer.program, cr.baseFile, cr.spec, "require");
     if (dep === null || dep.fileName.endsWith(".json"))
         return null;
@@ -1161,6 +1163,9 @@ export function lowerFsToUnixTimestampCall(lowerer, expr, bi, loc) {
  * after every validation passes, exactly Node's order. Null when this
  * is not a claimed member/shape (the table or fence path stands). */
 export function lowerFsLadderCall(lowerer, expr, bi, loc) {
+    if (bi.module === "fs" && bi.member !== "rename" && builtinModuleFnOf(lowerer, bi.module, bi.member)?.fn === "fs.callbackCall") {
+        return lowerer.lowerBuiltinModuleCall(expr, bi, { fn: "fs.callbackCall", params: [], result: DYN }, loc);
+    }
     if (bi.module !== "fs" && bi.module !== "fs/promises")
         return null;
     if (!isJsSourceFile(expr.getSourceFile()))
@@ -1410,6 +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.
@@ -2318,17 +2353,35 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     }
     return { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
 }
-/** Reflect.apply(target, thisArg, argsList) where the TARGET is a builtin
+/** Reflect.ownKeys uses native computed-key reflection. Reflect.apply(target,
+   * thisArg, argsList) where the TARGET is a builtin
    * rest-parameter table fn (path.join / path.resolve — test/common
    * fixtures.js's fixturesPath forwards its rest args exactly this way):
    * the packed libCall over a validated string[] extraction of argsList.
    * The builtins ignore the receiver, so thisArg must be an effect-free
    * spelling (`this`, an identifier, a unit literal) whose dropped
    * evaluation is unobservable; every other Reflect.apply keeps the
-   * fence. Null when this isn't a Reflect.apply call. */
-export function lowerReflectApplyCall(lowerer, call, access) {
+   * fence. Null when this isn't a supported Reflect call. */
+export function lowerReflectCall(lowerer, call, access) {
+    if (!call.questionDotToken && !access.questionDotToken && lowerer.stdlibGlobalMember(access, "Reflect") === "ownKeys" &&
+        call.arguments.length === 1 && !ts.isSpreadElement(call.arguments[0])) {
+        return { kind: "libCall", fn: "dyn.ownKeys", args: [lowerer.lowerExprExpecting(call.arguments[0], DYN)], type: DYN, loc: locOf(call) };
+    }
     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);
@@ -2340,7 +2393,10 @@ export function lowerReflectApplyCall(lowerer, call, access) {
     const bi = ts.isPropertyAccessExpression(targetNode) ? lowerer.builtinMemberOf(targetNode) : null;
     const fn = bi ? builtinModuleFnOf(lowerer, bi.module, bi.member) : null;
     if (!fn || fn.variadicPack !== true) {
-        lowerer.noLowering(`Reflect.apply of '${targetNode.getText()}'`, targetNode, fenceHint);
+        const target = lowerer.lowerExprExpecting(targetNode, DYN);
+        const receiver = lowerer.lowerExprExpecting(call.arguments[1], DYN);
+        const argumentsList = lowerer.lowerExprExpecting(call.arguments[2], DYN);
+        return { kind: "libCall", fn: "dyn.reflectApply", args: [target, receiver, argumentsList], type: DYN, loc };
     }
     const thisNode = call.arguments[1];
     const effectFree = thisNode.kind === ts.SyntaxKind.ThisKeyword ||
@@ -2524,8 +2580,8 @@ export function lowerSpawnSyncCall(lowerer, expr, loc) {
     };
 }
 /** `spawn(command, args?, options)` → one cp.spawn / cp.spawnOpts
-   * libCall. The options argument, when present, must be an object
-   * LITERAL. Stdio accepts "ignore", "inherit", or "pipe" as the scalar,
+   * libCall. Computed options use native runtime normalization. Inline
+   * stdio accepts "ignore", "inherit", or "pipe" as the scalar,
    * or the 3-tuple whose stdin pipe becomes child.stdin, stdout/stderr
    * pipes become child.stdout/child.stderr, and output slots may also be
    * number fds. Omitting stdio uses Node's default: all three piped. The
@@ -2559,7 +2615,11 @@ export function lowerSpawnCall(lowerer, expr, loc) {
             optsNode = second;
     }
     if (optsNode !== undefined && !ts.isObjectLiteralExpression(optsNode)) {
-        lowerer.noLowering("spawn with a non-literal options argument", optsNode, "pass stdio, detached, env, cwd, windowsHide, and shell in an inline object literal");
+        return {
+            kind: "libCall", fn: "cp.spawnDynamic",
+            args: [cmd, lowerer.lowerChildArgsArg(argsNode, loc), lowerer.lowerExprExpecting(optsNode, DYN)],
+            type: CHILD_T, loc,
+        };
     }
     const emptyStr = { kind: "strLit", value: "", type: STRING, loc };
     // Per-slot stdio modes (scr_child.c: 0 ignore, 1 inherit, 2 fd) and
@@ -4166,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;
@@ -4182,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
@@ -4242,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 = [
@@ -4282,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;
 }
@@ -4312,6 +4393,18 @@ export function lowerJsonMethodCall(lowerer, call, access) {
         return { kind: "libCall", fn: "json.parseReviver", args: [text, callback], type: DYN, loc };
     }
     if (member === "stringify") {
+        const replacerNode = call.arguments[1];
+        const spaceNode = call.arguments[2];
+        const runtimeOptions = replacerNode && !jsonNullishArgument(lowerer, replacerNode) &&
+            lowerer.mapTypeOf(lowerer.typeOf(replacerNode))?.kind === "dyn" ||
+            spaceNode && !jsonNullishArgument(lowerer, spaceNode) &&
+                !ts.isNumericLiteral(spaceNode) && !ts.isStringLiteral(spaceNode) && !ts.isNoSubstitutionTemplateLiteral(spaceNode) &&
+                !(ts.isPrefixUnaryExpression(spaceNode) && ts.isNumericLiteral(spaceNode.operand));
+        if (runtimeOptions && call.arguments[0]) {
+            const args = [0, 1, 2].map((index) => call.arguments[index]
+                ? lowerer.lowerExprExpecting(call.arguments[index], DYN) : dynUndefinedExpr(loc));
+            return { kind: "libCall", fn: "json.stringifyValue", args, type: DYN, loc };
+        }
         const indent = stringifySpaceIndent(lowerer, call);
         if (call.arguments.length === 0) {
             return lowerer.wrappedUndefined(lowerer.withUndefinedArm(STRING), loc);
@@ -4366,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 }],
@@ -4516,6 +4609,12 @@ function jsonNullishArgument(lowerer, node) {
  * refuse signatures that request one until that protocol is implemented. */
 function lowerJsonCallback(lowerer, node, role) {
     const callback = lowerer.lowerExpr(node);
+    if (callback.type.kind === "dyn")
+        return callback;
+    if (callback.type.kind === "union" && lowerer.dynConvertible(callback.type) &&
+        lowerer.unions.get(callback.type.unionId)?.arms.every((arm) => isUnitType(arm) || arm.kind === "func" &&
+            arm.params.length <= 2 && (role !== "reviver" || (!arm.rest && !arm.argumentsAll))))
+        return lowerer.coerceToExpected(callback, DYN);
     if (callback.type.kind === "func" && callback.type.params.length <= 2 &&
         (role !== "reviver" || (!callback.type.rest && !callback.type.argumentsAll)) &&
         canBoxFuncIntoDyn(callback.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
@@ -4702,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);
 }
@@ -4722,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) };
@@ -4744,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));
 }
@@ -4793,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");
@@ -4900,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) {
@@ -4911,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,
@@ -4959,6 +5095,9 @@ export function lowerSearchParamsNew(lowerer, expr, loc) {
         return acc;
     }
     const init = lowerer.lowerExpr(arg);
+    if (init.type.kind === "dyn") {
+        return { kind: "libCall", fn: "sp.newChecked", args: [init], type: SEARCH_PARAMS_T, loc };
+    }
     if (init.type.kind === "string") {
         return { kind: "libCall", fn: "sp.parse", args: [init], type: SEARCH_PARAMS_T, loc };
     }
@@ -5286,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) ?? [];
@@ -5343,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 };
@@ -5358,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);
@@ -5415,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]]])");
@@ -5473,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
@@ -5627,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).
@@ -5637,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))
@@ -5817,7 +6066,7 @@ export function lowerChildMethodCall(lowerer, call, access) {
     if ((name === "on" || name === "once") && call.arguments.length === 2) {
         const evT = lowerer.typeOf(call.arguments[0]);
         const event = evT.isStringLiteralType() ? evT.value : null;
-        if (event !== "exit" && event !== "close" && event !== "error" && event !== "message" && event !== "disconnect") {
+        if (event !== "spawn" && event !== "exit" && event !== "close" && event !== "error" && event !== "message" && event !== "disconnect") {
             lowerer.noLowering(`child.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"exit", "close", "error", "message", and "disconnect" are the supported child events (as literals)');
         }
         if (!ts.isExpressionStatement(call.parent)) {
@@ -5843,7 +6092,34 @@ export function lowerChildMethodCall(lowerer, call, access) {
                 loc,
             };
         }
+        const listenerNode = stripTypeCasts(call.arguments[1]);
+        if (isJsSourceFile(listenerNode.getSourceFile()) &&
+            (ts.isArrowFunction(listenerNode) || ts.isFunctionExpression(listenerNode)) &&
+            listenerNode.parameters.some((param) => param.dotDotDotToken) &&
+            listenerNode.parameters.every((param) => !param.type) &&
+            !/@(?:param|type)\b/.test(listenerNode.getSourceFile().text.slice(listenerNode.pos, listenerNode.getStart()))) {
+            for (const param of listenerNode.parameters)
+                lowerer.checkedCallbackParams.add(param);
+        }
         const cb = lowerer.lowerExpr(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 },
+                    cb.type.kind === "dyn" ? cb : { kind: "dynFrom", value: cb, type: DYN, loc }],
+                type: VOID, loc,
+            };
+        }
+        if (event === "spawn") {
+            if (cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void") {
+                lowerer.noLowering("spawn event listeners with parameters or a returned value", call.arguments[1]);
+            }
+            return { kind: "libCall", fn: "child.onSpawn", args: [receiver, cb], type: VOID, loc };
+        }
         if (cb.type.kind !== "func" || cb.type.params.length > (event === "error" ? 1 : 2)) {
             lowerer.unsupported("SC1090", call.arguments[1], event !== "error"
                 ? `${event} listeners with more than two parameters (use (code, signal), (code), or ())`
@@ -5918,9 +6194,9 @@ export function lowerChildMethodCall(lowerer, call, access) {
     // child.unref(): drops the child from the event loop's keep-alive set
     // (the process may exit while the child runs — Node's semantics; the
     // child is still reaped while the loop runs for other reasons).
-    if (name === "unref" && call.arguments.length === 0) {
+    if ((name === "unref" || name === "ref") && call.arguments.length === 0) {
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: "child.unref", args: [receiver], type: VOID, loc };
+        return { kind: "libCall", fn: name === "ref" ? "child.ref" : "child.unref", args: [receiver], type: VOID, loc };
     }
     lowerer.noLowering(`ChildProcess.${name}`, call, "send(), connected, disconnect(), on/once(\"message\" | \"disconnect\" | \"exit\" | \"close\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are supported", lowerer.checker.getSymbolAtLocation(access.name));
 }
@@ -6217,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",
@@ -6259,10 +6536,10 @@ export function lowerFsConstantsProperty(lowerer, expr) {
     const bi = lowerer.builtinImportOf(expr.expression);
     if (!bi || bi.module !== "fs" || bi.member !== "constants")
         return null;
-    const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4 };
+    const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4, COPYFILE_EXCL: 1, COPYFILE_FICLONE: 2, COPYFILE_FICLONE_FORCE: 4 };
     const value = own(MODES, expr.name.text);
     if (value === undefined) {
-        lowerer.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
+        lowerer.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
     }
     return { kind: "numLit", value, type: F64, loc: locOf(expr) };
 }
@@ -6917,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
@@ -6934,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);
@@ -7777,7 +8069,7 @@ export function lowerDateCall(lowerer, call, access) {
 export function lowerTextCodecNew(lowerer, ctor, cls) {
     const args = ctor.arguments ?? [];
     const loc = locOf(ctor);
-    let encoding = -1;
+    let encoding = { kind: "numLit", value: -1, type: F64, loc };
     let label = null;
     if (cls === "TextEncoder") {
         if (args.length !== 0)
@@ -7786,17 +8078,39 @@ export function lowerTextCodecNew(lowerer, ctor, cls) {
     else if (args.length !== 0) {
         const labelT = lowerer.typeOf(args[0]);
         const parsed = labelT.isStringLiteralType() ? staticTextDecoderEncoding(labelT.value) : null;
-        if (args.length !== 1 || parsed === null) {
-            lowerer.noLowering("new TextDecoder with runtime-valued options or an unknown label", ctor, "a recognized literal WHATWG label with default options compiles");
+        if (args.length > 2)
+            lowerer.noLowering("new TextDecoder with extra arguments", ctor);
+        if (parsed === null) {
+            encoding = { kind: "libCall", fn: "text.decoderEncoding", args: [lowerer.lowerExprExpecting(args[0], DYN)], type: F64, loc };
+        }
+        else {
+            encoding = { kind: "numLit", value: parsed.kind === "utf8" ? -1 : parsed.id, type: F64, loc };
+            label = lowerer.lowerExprExpecting(args[0], STRING);
+        }
+    }
+    const options = args[1] ? stripTypeCasts(args[1]) : null;
+    const flags = new Map();
+    for (const name of ["fatal", "ignoreBOM"])
+        flags.set(name, { kind: "boolLit", value: false, type: BOOL, loc });
+    if (options) {
+        if (!ts.isObjectLiteralExpression(options))
+            lowerer.noLowering("TextDecoder options outside an object literal", options);
+        for (const property of options.properties) {
+            if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+                !ts.isIdentifier(property.name) || !flags.has(property.name.text))
+                lowerer.noLowering("unknown TextDecoder option", property);
+            const value = ts.isPropertyAssignment(property) ? property.initializer : property.name;
+            flags.set(property.name.text, lowerer.lowerExprExpecting(value, BOOL));
         }
-        encoding = parsed.kind === "utf8" ? -1 : parsed.id;
-        label = lowerer.lowerExprExpecting(args[0], STRING);
     }
     const type = lowerer.mapTypeOf(lowerer.typeOf(ctor));
     if (type?.kind !== "record")
         lowerer.badType(ctor, lowerer.typeOf(ctor));
     const result = {
-        kind: "recordLit", fields: [{ name: `%${cls}`, value: { kind: "numLit", value: encoding, type: F64, loc } }], type, loc,
+        kind: "recordLit", fields: [{ name: `%${cls}`, value: encoding }, ...(cls === "TextDecoder" ? [
+                ...[...flags].map(([name, value]) => ({ name: `%${name}`, value })),
+                { name: "%state", value: { kind: "dynObjLit", fields: [], type: DYN, loc } },
+            ] : [])], type, loc,
     };
     return label === null || label.kind === "strLit" ? result : {
         kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: label, loc }], result, type, loc,
@@ -7814,17 +8128,32 @@ function lowerStoredTextCodecCall(lowerer, call, access) {
         return null;
     if (access.name.text !== (cls === "TextEncoder" ? "encode" : "decode"))
         return null;
-    if (call.arguments.length > 1) {
-        lowerer.noLowering(cls === "TextDecoder" ? "decode with a stream option" : "TextEncoder.encode with extra arguments", call);
+    if (call.arguments.length > (cls === "TextDecoder" ? 2 : 1)) {
+        lowerer.noLowering(`${cls}.${access.name.text} with extra arguments`, call);
     }
     const loc = locOf(call);
+    let stream = { kind: "boolLit", value: false, type: BOOL, loc };
+    if (cls === "TextDecoder" && call.arguments[1]) {
+        const options = stripTypeCasts(call.arguments[1]);
+        if (!ts.isObjectLiteralExpression(options))
+            lowerer.noLowering("TextDecoder.decode options outside an object literal", options);
+        for (const property of options.properties) {
+            if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+                !ts.isIdentifier(property.name) || property.name.text !== "stream")
+                lowerer.noLowering("unknown TextDecoder.decode option", property);
+            stream = lowerer.lowerExprExpecting(ts.isPropertyAssignment(property) ? property.initializer : property.name, BOOL);
+        }
+    }
     const receiver = lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "record")
         lowerer.badType(access.expression, lowerer.typeOf(access.expression));
-    const arg = call.arguments.length === 0
+    let arg = call.arguments.length === 0
         ? cls === "TextEncoder" ? strLit("", loc)
             : { kind: "bytesNew", source: null, type: BYTES_U8, loc }
         : cls === "TextEncoder" ? lowerer.lowerExprExpecting(call.arguments[0], STRING) : lowerer.lowerExpr(call.arguments[0]);
+    if (cls === "TextDecoder" && (arg.type.kind === "dyn" || arg.type.kind === "bytes" && arg.type.elem !== "u8")) {
+        arg = { kind: "libCall", fn: "bytes.bufferSource", args: [lowerer.coerceInto(call.arguments[0], arg, DYN)], type: BYTES_U8, loc };
+    }
     if (cls === "TextDecoder" && !(arg.type.kind === "bytes" && arg.type.elem === "u8")) {
         lowerer.noLowering(`TextDecoder.decode of '${lowerer.fmt(arg.type)}' values`, call, "Uint8Array/Buffer input decodes (ArrayBuffer values have no representation)");
     }
@@ -7837,22 +8166,22 @@ function lowerStoredTextCodecCall(lowerer, call, access) {
         const input = varRef("input.0", arg.type, loc);
         const result = cls === "TextEncoder"
             ? { kind: "libCall", fn: "buffer.fromStr", args: [input, { kind: "strLit", value: "utf8", type: STRING, loc }], type: BYTES_U8, loc }
-            : {
-                kind: "ternary",
-                cond: { kind: "bin", op: "<", left: { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc }, right: { kind: "numLit", value: 0, type: F64, loc }, type: BOOL, loc },
-                then: { kind: "libCall", fn: "text.decode", args: [input], type: STRING, loc },
-                else_: { kind: "libCall", fn: "text.decodeLegacy", args: [input, { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc }], type: STRING, loc },
-                type: STRING, loc,
-            };
+            : { kind: "libCall", fn: "text.decodeStream", args: [
+                    { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%state", type: DYN, loc },
+                    input,
+                    { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc },
+                    ...["%fatal", "%ignoreBOM"].map((field) => ({ kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field, type: BOOL, loc })),
+                    varRef("stream.0", BOOL, loc),
+                ], type: STRING, loc };
         lowerer.liftedFns.push({
             name,
-            params: [{ localId: "codec.0", name: "codec", type: recT }, { localId: "input.0", name: "input", type: arg.type }],
+            params: [{ localId: "codec.0", name: "codec", type: recT }, { localId: "input.0", name: "input", type: arg.type }, { localId: "stream.0", name: "stream", type: BOOL }],
             returnType: result.type,
-            locals: [{ id: "codec.0", name: "codec", type: recT, mutable: false }, { id: "input.0", name: "input", type: arg.type, mutable: false }],
+            locals: [{ id: "codec.0", name: "codec", type: recT, mutable: false }, { id: "input.0", name: "input", type: arg.type, mutable: false }, { id: "stream.0", name: "stream", type: BOOL, mutable: false }],
             body: [{ kind: "return", value: result, loc }], loc,
         });
     }
-    return { kind: "call", callee: name, args: [receiver, arg], type: cls === "TextEncoder" ? BYTES_U8 : STRING, loc };
+    return { kind: "call", callee: name, args: [receiver, arg, stream], type: cls === "TextEncoder" ? BYTES_U8 : STRING, loc };
 }
 /** A direct construction of THE stdlib TextEncoder/TextDecoder, through
    * type-only wrappers. Name alone is never enough: a user class with the
@@ -7885,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);
@@ -7893,6 +8234,8 @@ export function lowerTextCodecCall(lowerer, call, access) {
     if (!lowerer.isStdlibMember(access))
         return null;
     const { cls, ctor: recv } = info;
+    if (cls === "TextDecoder" && ((recv.arguments?.length ?? 0) > 1 || call.arguments.length > 1))
+        return lowerStoredTextCodecCall(lowerer, call, access);
     if (!(cls === "TextDecoder" && member === "decode") && !(cls === "TextEncoder" && member === "encode")) {
         return null;
     }
@@ -7909,7 +8252,7 @@ export function lowerTextCodecCall(lowerer, call, access) {
                 ? staticTextDecoderEncoding(labelT.value)
                 : null;
         if (ctorArgs.length > 1 || encoding === null) {
-            lowerer.noLowering("new TextDecoder with runtime-valued options or an unknown label", recv, "a recognized literal WHATWG label with default options compiles");
+            return lowerStoredTextCodecCall(lowerer, call, access);
         }
         const labelEffect = ctorArgs.length === 1
             ? lowerer.lowerExprExpecting(ctorArgs[0], STRING)
@@ -7931,7 +8274,10 @@ export function lowerTextCodecCall(lowerer, call, access) {
             lowerer.noLowering("decode with a stream option", call, "streaming decode has no lowering — decode whole buffers");
         }
         const argNode = call.arguments[0];
-        const arg = lowerer.lowerExpr(argNode);
+        let arg = lowerer.lowerExpr(argNode);
+        if (arg.type.kind === "dyn" || arg.type.kind === "bytes" && arg.type.elem !== "u8") {
+            arg = { kind: "libCall", fn: "bytes.bufferSource", args: [lowerer.coerceInto(argNode, arg, DYN)], type: BYTES_U8, loc };
+        }
         if (!(arg.type.kind === "bytes" && arg.type.elem === "u8")) {
             lowerer.noLowering(`TextDecoder.decode of '${lowerer.fmt(arg.type)}' values`, argNode, "Uint8Array/Buffer input decodes (ArrayBuffer values have no representation)");
         }
@@ -8159,7 +8505,7 @@ export function lowerPromiseStaticCall(lowerer, call, access) {
             // reads are the routed keyed ops). All-static tuples keep the
             // typed fence hint below. --dynamic only by construction: jsval
             // entries exist only there.
-            if (elems.some((e) => e.type.kind === "jsval")) {
+            if (lowerer.dynamic && elems.some((e) => e.type.kind === "jsval" || e.type.kind === "dyn")) {
                 const diagsBefore = lowerer.diags.length;
                 try {
                     const marshaled = argNode.elements.map((el, i) => lowerer.jsvalIn(elems[i], el));
@@ -8183,16 +8529,21 @@ 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
         // marshaled array (an 'any' value passes through; an `any[]` value
         // lifts per element by reference), the result staying an island
         // value the static side awaits through the island→static bridge.
-        if (entries.type.kind === "jsval" ||
+        if (entries.type.kind === "jsval" || lowerer.dynamic && entries.type.kind === "dyn" ||
             (entries.type.kind === "array" && entries.type.elem.kind === "jsval")) {
             const diagsBefore = lowerer.diags.length;
             try {
@@ -8368,11 +8719,12 @@ export function lowerPromiseStaticCall(lowerer, call, access) {
             return { kind: "intrinsic", name: "promise.resolve", args: [], type: { kind: "promise", inner: VOID }, loc };
         }
         if (resultT.inner.kind === "void") {
-            // Promise.resolve(expr) at a void-promise type: the argument's
-            // effects must still run — no statement slot exists here for
-            // them, so only effect-free spellings could drop it honestly;
-            // fence rather than model that corner.
-            lowerer.noLowering("Promise.resolve with an argument at a void-promise type", call);
+            return {
+                kind: "seqExpr",
+                stmts: [lowerer.lowerExprStatement(argNode)],
+                result: { kind: "intrinsic", name: "promise.resolve", args: [], type: resultT, loc },
+                type: resultT, loc,
+            };
         }
         if (isUnitType(resultT.inner)) {
             // A unit payload (Promise<undefined>/Promise<null>) has no
@@ -8392,6 +8744,9 @@ export function lowerNumberStaticProperty(lowerer, expr) {
     const member = lowerer.stdlibGlobalMember(expr, "Number");
     if (member === null)
         return null;
+    const predicate = own(NUMBER_STATIC_PREDICATES, member);
+    if (predicate)
+        return lowerCheckedPredicateValue(lowerer, `Number.${member}`, "number", locOf(expr), predicate);
     const value = own(NUMBER_CONSTANTS, member);
     if (value === undefined)
         return null;