@scriptc/compiler 0.1.7 → 0.2.1

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

@@ -1,3 +1,4 @@
+import { staticTextDecoderEncoding } from "./text-decoder-encoding.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
@@ -6,8 +7,9 @@ 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, isJsSourceFile, isNodeEsmFile, locOf, npmStaticDepSf7, requireSpecOf, resolveImport } from "../program.js";
+import { canonicalBuiltinModule, isCreateRequireBinding7, isJsSourceFile, isNodeEsmFile, locOf, npmStaticDepSf7, requireSpecOf, resolveImport } from "../program.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { probeNodeRequireRefusal } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
@@ -24,11 +26,14 @@ import { CRYPTO_CIPHERS, CRYPTO_CONSTANTS, CRYPTO_CURVES, CRYPTO_HASHES } from "
 import { generatorMeta, timerStyleCallback } from "./lower-calls.js";
 import { registerHttpClientFnBinding, voidizedCallback } from "./lower-server.js";
 import { pairsSnapshotHelper } from "./pairs-snapshot.js";
+import { isJsonStringifyDynamicType } from "../../ir/ir.js";
 import { bufEncoding } from "./containers/bytes.js";
 import { BOOL, BYTES_U8, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DYN, F64, FILEHANDLE_T, FSWATCHER_T, PROCSTREAM_T, JSVAL, NULL_T, SEARCH_PARAMS_T, SPAWNRES_T, STRING, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, funcOf, isUnitType, typeEquals, typeKey } from "../../ir/ir.js";
 import { boolLit, countedFor, numLit, strLit, varRef } from "../../ir/build.js";
 import { staticForkModulePath } from "../fork-target.js";
 import { tsgoPath } from "../dts-paths.js";
+import { lowerFfiMemoryModule } from "./native-ffi.js";
+import { lowerBuiltinLoaderValue } from "./lower-builtin-values.js";
 function optionalStringTags(lowerer, type) {
     if (type.kind !== "union")
         return null;
@@ -122,14 +127,16 @@ function checkedOptionalBuiltinArm(lowerer, value, target) {
         : null;
 }
 function lowerOptionalNumberPredicate(lowerer, value, fn, loc) {
-    const widened = lowerer.runtimeOptionalWidening(value.type, F64);
-    if (!widened || widened.kind !== "union")
+    // Number predicates do not coerce. In a mixed union only the numeric
+    // arm runs the predicate; every other arm answers false after evaluating
+    // the argument once. This includes the undefined added by array reads.
+    const widened = value.type;
+    if (widened.kind !== "union" && widened.kind !== "dyn")
         return null;
-    const numberTag = lowerer.armTag(widened.unionId, F64);
-    const undefinedTag = lowerer.armTag(widened.unionId, UNDEFINED_T);
-    if (numberTag < 0 || undefinedTag < 0)
+    const numberTag = widened.kind === "union" ? lowerer.armTag(widened.unionId, F64) : -1;
+    if (widened.kind === "union" && numberTag < 0)
         return null;
-    const key = `number.optionalPredicate:${fn}:${widened.unionId}`;
+    const key = `number.optionalPredicate:${fn}:${typeKey(widened)}`;
     let helper = lowerer.widthHelpers.get(key);
     if (!helper) {
         helper = `%number.optionalPredicate.${lowerer.widthHelpers.size}`;
@@ -143,7 +150,9 @@ function lowerOptionalNumberPredicate(lowerer, value, fn, loc) {
             body: [
                 {
                     kind: "if",
-                    cond: { kind: "unionIsTag", unionId: widened.unionId, tag: undefinedTag, negated: false, value: input, type: BOOL, loc },
+                    cond: widened.kind === "dyn"
+                        ? { kind: "dynTest", test: "number", negated: true, value: input, type: BOOL, loc }
+                        : { kind: "unionIsTag", unionId: widened.unionId, tag: numberTag, negated: true, value: input, type: BOOL, loc },
                     then: [{ kind: "return", value: boolLit(false, loc), loc }],
                     else_: null,
                     loc,
@@ -153,7 +162,9 @@ function lowerOptionalNumberPredicate(lowerer, value, fn, loc) {
                     value: {
                         kind: "libCall",
                         fn,
-                        args: [{ kind: "unionNarrow", unionId: widened.unionId, tag: numberTag, value: input, type: F64, loc }],
+                        args: [widened.kind === "dyn"
+                                ? { kind: "dynCheck", value: input, type: F64, loc }
+                                : { kind: "unionNarrow", unionId: widened.unionId, tag: numberTag, value: input, type: F64, loc }],
                         type: BOOL,
                         loc,
                     },
@@ -198,7 +209,9 @@ function lowerBuiltinOptionalDefault(lowerer, node, expected, dflt, nullIsDefaul
    * declaration is not an import specifier. Returns the CANONICAL module
    * name and the EXPORTED member name (not the local alias). */
 export function builtinImportOf(lowerer, ident) {
-    const symbol = lowerer.checker.getSymbolAtLocation(ident);
+    const symbol = ts.isShorthandPropertyAssignment(ident.parent) && ident.parent.name === ident
+        ? lowerer.checker.getShorthandAssignmentValueSymbol(ident.parent)
+        : lowerer.checker.getSymbolAtLocation(ident);
     const decl = symbol ? lowerer.checker.declarationsOf(symbol)[0] : undefined;
     if (!decl)
         return null;
@@ -206,7 +219,7 @@ export function builtinImportOf(lowerer, ident) {
     // binding (`const { readFileSync } = require("fs")`, renames via
     // `{ readFileSync: rf }`) keys the same tables.
     if (ts.isBindingElement(decl) && decl.name !== undefined && ts.isIdentifier(decl.name)) {
-        const varDecl = decl.parent.parent;
+        const varDecl = decl.parent?.parent;
         if (ts.isObjectBindingPattern(decl.parent) &&
             ts.isVariableDeclaration(varDecl) &&
             varDecl.initializer !== undefined) {
@@ -246,7 +259,7 @@ export function builtinImportOf(lowerer, ident) {
     if (!ts.isImportSpecifier(decl) && !ts.isExportSpecifier(decl))
         return null;
     if (ts.isImportSpecifier(decl)) {
-        const importDecl = decl.parent.parent.parent;
+        const importDecl = decl.parent?.parent?.parent;
         if (!ts.isImportDeclaration(importDecl) || !ts.isStringLiteral(importDecl.moduleSpecifier)) {
             return null;
         }
@@ -370,7 +383,7 @@ function createRequireBaseCallOf(lowerer, expr) {
     if (e.arguments.length !== 1)
         return null;
     const base = stripTypeCasts(e.arguments[0]);
-    if (ts.isIdentifier(base) && base.text === "__filename")
+    if (ts.isIdentifier(base) && lowerer.isStdlibGlobal(base, "__filename"))
         return e;
     if (ts.isPropertyAccessExpression(base) &&
         !base.questionDotToken &&
@@ -384,15 +397,22 @@ function createRequireBaseCallOf(lowerer, expr) {
 /** True for `const require = createRequire(import.meta.url)` — the
    * binding is compile-time plumbing (each call through it resolves per
    * site) with no storage and no code; both declaration walks skip by
-   * this test. A reassignable (let/var) binding never matches — callers
-   * gate on constness like the other alias decls. */
+   * this test. Top-level let/var bindings also qualify when preflight's
+   * shared proof rules out writes, escapes, and use before initialization. */
 export function createRequireBindingDecl(lowerer, nameNode, init) {
-    if (!ts.isIdentifier(nameNode) || init === undefined)
+    if (!ts.isIdentifier(nameNode) || init === undefined || createRequireBaseCallOf(lowerer, init) === null)
         return false;
-    return createRequireBaseCallOf(lowerer, init) !== null;
+    // Preserve const loaders acquired through CommonJS member/destructure
+    // aliases, which builtinImportOf also recognizes. Mutable syntax uses
+    // preflight's narrower import provenance and whole-file stability proof.
+    const decl = nameNode.parent;
+    if (ts.isVariableDeclaration(decl) && ts.isVariableDeclarationList(decl.parent) &&
+        (decl.parent.flags & ts.NodeFlags.Const) !== 0)
+        return true;
+    return isCreateRequireBinding7(lowerer.program, nameNode);
 }
 /** The declaring source file when `callee` denotes a createRequire-made
-   * require: a CONST binding over createRequire(import.meta.url) (the
+   * require: a stable binding over createRequire(import.meta.url) (the
    * binding's own file anchors resolution) or the inline
    * `createRequire(import.meta.url)(...)` spelling (the call's file).
    * Null off the pattern, so call chains keep trying. */
@@ -407,9 +427,7 @@ export function createRequireCalleeFileOf(lowerer, callee) {
     const decl = symbol ? lowerer.checker.declarationsOf(symbol)[0] : undefined;
     if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined)
         return null;
-    if (!ts.isVariableDeclarationList(decl.parent) || (decl.parent.flags & ts.NodeFlags.Const) === 0)
-        return null;
-    return createRequireBaseCallOf(lowerer, decl.initializer) !== null ? decl.getSourceFile() : null;
+    return createRequireBindingDecl(lowerer, decl.name, decl.initializer) ? decl.getSourceFile() : null;
 }
 /** The static require of `R("spec")` through a createRequire binding:
    * the literal specifier plus the file anchoring relative resolution.
@@ -428,6 +446,14 @@ export function createRequireSpecOf(lowerer, call) {
     const a = call.arguments[0];
     return { spec: ts.isStringLiteralLike(a) ? a.text : null, baseFile };
 }
+/** node:ffi is a checked native module value, so its require binding needs
+ * storage even when the createRequire loader is named `require`. */
+export function isNativeFfiRequire(lowerer, expr) {
+    if (expr === undefined)
+        return false;
+    const call = stripTypeCasts(expr);
+    return ts.isCallExpression(call) && createRequireSpecOf(lowerer, call)?.spec === "node:ffi";
+}
 /** True for `const fs = require("node:fs")` through a createRequire
    * binding — a builtin namespace import in const clothing: alias
    * plumbing with no storage (uses resolve through
@@ -455,8 +481,8 @@ 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) ??
-        npmStaticDepSf7(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;
     return { spec: cr.spec, baseFile: cr.baseFile, dep };
@@ -567,6 +593,9 @@ export function lowerCreateRequireCall(lowerer, call, loc) {
         lowerer.noLowering("createRequire's require with this argument shape", call, "the compiled module graph is fixed at build time — the one lowered form is require(\"<static string literal>\")");
     }
     const spec = cr.spec;
+    if (spec === "node:ffi") {
+        return lowerFfiMemoryModule(lowerer, loc);
+    }
     if (canonicalBuiltinModule(spec) !== null) {
         lowerer.unsupported("SC1090", call, `module namespace objects as values (bind it first: const m = require("${spec}"), then access members through the binding)`);
     }
@@ -585,7 +614,7 @@ export function lowerCreateRequireCall(lowerer, call, loc) {
             // This probe marks frontend inputs unstable, but every branch
             // here refuses compilation, so successful-build caches keep their
             // existing dependency proofs.
-            const resolved = resolveRequireRuntime(cr.baseFile.fileName, spec, lowerer.targetPlatform);
+            const resolved = resolveRequireRuntime(cr.baseFile.fileName, spec, lowerer.targetPlatform, undefined, lowerer.frontendServices);
             if (resolved.ok && resolved.value.endsWith(".node")) {
                 lowerer.pushDiag(nativeAddonDiag(spec, loc));
                 throw new PoisonError();
@@ -684,7 +713,7 @@ export function lowerImportMetaResolveCall(lowerer, call) {
     if (specifier === null) {
         lowerer.noLowering("import.meta.resolve with a runtime-computed specifier", call.arguments[0], "a compiled binary has a fixed module graph — pass a string literal");
     }
-    const result = resolveImportMetaRuntime(call.getSourceFile().fileName, specifier, lowerer.targetPlatform);
+    const result = resolveImportMetaRuntime(call.getSourceFile().fileName, specifier, lowerer.targetPlatform, lowerer.frontendServices);
     if (result === null) {
         lowerer.noLowering(`import.meta.resolve of '${specifier}'`, call, "relative paths, URL-like names, builtins, and installed package names are supported; package-import aliases remain unsupported");
     }
@@ -697,7 +726,7 @@ function requireResolverBaseFile(lowerer, receiver) {
     const created = createRequireCalleeFileOf(lowerer, receiver);
     if (created !== null)
         return created;
-    return lowerer.isStdlibGlobal(receiver, "require") && !isNodeEsmFile(receiver.getSourceFile())
+    return lowerer.isStdlibGlobal(receiver, "require") && !isNodeEsmFile(receiver.getSourceFile(), lowerer.program)
         ? receiver.getSourceFile()
         : null;
 }
@@ -761,7 +790,7 @@ export function lowerRequireResolveCall(lowerer, call) {
     }
     const loc = locOf(call);
     if (pathsCall) {
-        const result = requireResolvePathsRuntime(baseFile.fileName, specifier, lowerer.targetPlatform);
+        const result = requireResolvePathsRuntime(baseFile.fileName, specifier, lowerer.targetPlatform, lowerer.frontendServices);
         if (result !== null && !Array.isArray(result)) {
             return runtimeResolveThrow(result, lowerer.irTypeOf(call), loc);
         }
@@ -779,7 +808,7 @@ export function lowerRequireResolveCall(lowerer, call) {
     if (paths === null) {
         lowerer.noLowering("require.resolve with runtime-computed options", call.arguments[1], "omit options or pass { paths: [\"<static directory>\", ...] }");
     }
-    const result = resolveRequireRuntime(baseFile.fileName, specifier, lowerer.targetPlatform, paths);
+    const result = resolveRequireRuntime(baseFile.fileName, specifier, lowerer.targetPlatform, paths, lowerer.frontendServices);
     return result.ok
         ? { kind: "strLit", value: result.value, type: STRING, loc }
         : runtimeResolveThrow(result.error, STRING, loc);
@@ -861,6 +890,13 @@ function isPerfHooksPerformanceExpr(lowerer, node) {
     }
     return false;
 }
+/** Presence probes do not extract an unbound Performance method value. */
+export function lowerPerfHooksTypeof(lowerer, expression) {
+    const value = isPerfHooksPerformanceExpr(lowerer, expression) ? "object" :
+        ts.isPropertyAccessExpression(expression) && !expression.questionDotToken && expression.name.text === "now" &&
+            isPerfHooksPerformanceExpr(lowerer, expression.expression) ? "function" : null;
+    return value === null ? null : { kind: "strLit", value, type: STRING, loc: locOf(expression) };
+}
 /** The node:perf_hooks spoke: `performance.now()` reads the runtime's
    * monotonic clock anchored at process start — Node's timeOrigin for a
    * compiled program, fractional milliseconds — and
@@ -1126,6 +1162,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()))
@@ -1300,6 +1339,31 @@ function lowerZlibModuleCall(lowerer, expr, bi, loc) {
     }
     const syncFn = ZLIB_SYNC_FNS[bi.member];
     if (syncFn !== undefined) {
+        if (expr.arguments.length === 2 &&
+            (bi.member === "deflateSync" || bi.member === "deflateRawSync" || bi.member === "gzipSync")) {
+            const options = expr.arguments[1];
+            // A literal level is enough for build-time compression in the native
+            // emitters. Other options retain the explicit refusal: silently
+            // dropping strategy/windowBits/dictionaries changes the wire bytes.
+            if (ts.isObjectLiteralExpression(options) && options.properties.length === 1) {
+                const prop = options.properties[0];
+                if (ts.isPropertyAssignment(prop) &&
+                    (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) && prop.name.text === "level") {
+                    const value = prop.initializer;
+                    const level = ts.isNumericLiteral(value) ? Number(value.text)
+                        : ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(value.operand)
+                            ? -Number(value.operand.text) : NaN;
+                    if (Number.isInteger(level) && level >= -1 && level <= 9) {
+                        return {
+                            kind: "libCall", fn: "zlib.deflateLevelSync",
+                            args: [zlibInputBytes(lowerer, expr.arguments[0], loc), numLit(bi.member === "deflateSync" ? 0 : bi.member === "deflateRawSync" ? 1 : 2, loc), numLit(level, loc)],
+                            type: BYTES_U8, loc,
+                        };
+                    }
+                }
+            }
+            lowerer.noLowering(`${bi.member} with these options`, options, "the static compression options form is { level: <integer literal from -1 through 9> }");
+        }
         if (expr.arguments.length !== 1) {
             const site = expr.arguments[1] ?? expr;
             lowerer.noLowering(`${bi.member} with explicit options`, site, `${bi.member}(data) with Node's default options is supported`);
@@ -1350,6 +1414,12 @@ function lowerZlibModuleCall(lowerer, expr, bi, loc) {
 }
 export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     const name = expr.expression.getText();
+    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 };
+    }
     // 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.
@@ -1979,15 +2049,21 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
             : { kind: "numLit", value: 0, type: F64, loc };
         return { kind: "libCall", fn: "fs.accessSync", args: [path, mode], type: VOID, loc };
     }
-    if (bi.module === "fs" && bi.member === "writeFileSync" && expr.arguments.length === 2) {
+    if (bi.module === "fs" && (bi.member === "writeFileSync" || bi.member === "appendFileSync") && expr.arguments.length === 2) {
         const dataIr = lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]));
+        if (dataIr?.kind === "union") {
+            const arms = lowerer.unions.get(dataIr.unionId)?.arms;
+            if (arms && arms.every((arm) => arm.kind === "string" || (arm.kind === "bytes" && arm.elem === "u8"))) {
+                return lowerStringOrBytesWrite(lowerer, expr, dataIr, arms, bi.member === "appendFileSync");
+            }
+        }
         if (dataIr?.kind === "bytes") {
             if (dataIr.elem !== "u8") {
-                lowerer.noLowering(`writeFileSync of '${lowerer.fmt(dataIr)}' data`, expr.arguments[1], "byte writes take Uint8Array/Buffer data");
+                lowerer.noLowering(`${bi.member} of '${lowerer.fmt(dataIr)}' data`, expr.arguments[1], "byte writes take Uint8Array/Buffer data");
             }
             const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
             const data = lowerer.lowerExprExpecting(expr.arguments[1], BYTES_U8);
-            return { kind: "libCall", fn: "fs.writeFileSyncBytes", args: [path, data], type: VOID, loc };
+            return { kind: "libCall", fn: bi.member === "appendFileSync" ? "fs.appendFileSyncBytes" : "fs.writeFileSyncBytes", args: [path, data], type: VOID, loc };
         }
     }
     // writeFileSync(p, data, options) / fs.promises.writeFile(p, data,
@@ -2145,6 +2221,27 @@ 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");
+            }
+            windowsNode = ts.isPropertyAssignment(property) ? property.initializer : property.name;
+        }
+        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");
     }
@@ -2164,6 +2261,8 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
         // 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 };
         }
@@ -2229,15 +2328,20 @@ 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;
     if (lowerer.stdlibGlobalMember(access, "Reflect") !== "apply")
@@ -2251,7 +2355,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 ||
@@ -2435,8 +2542,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
@@ -2470,7 +2577,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
@@ -3813,20 +3924,20 @@ export function lowerAlsMethodCall(lowerer, call, access) {
     const loc = locOf(call);
     if (name === "getStore" && call.arguments.length === 0) {
         const receiver = lowerer.lowerExprExpecting(access.expression, F64);
-        return { kind: "libCall", fn: "als.get", args: [receiver], type: DYN, loc };
+        return alsTypedResult(lowerer, call, { kind: "libCall", fn: "als.get", args: [receiver], type: DYN, loc });
     }
     if (name === "run" && call.arguments.length >= 2) {
         const receiver = lowerer.lowerExprExpecting(access.expression, F64);
         const value = dcMessageArg(lowerer, call.arguments[0]);
         const fn = dcSubscriberArg(lowerer, call.arguments[1]);
         const rest = dcTraceArgsArr(lowerer, call.arguments.slice(2), loc);
-        return { kind: "libCall", fn: "als.run", args: [receiver, value, fn, rest], type: DYN, loc };
+        return alsTypedResult(lowerer, call, { kind: "libCall", fn: "als.run", args: [receiver, value, fn, rest], type: DYN, loc });
     }
     if (name === "exit" && call.arguments.length >= 1) {
         const receiver = lowerer.lowerExprExpecting(access.expression, F64);
         const fn = dcSubscriberArg(lowerer, call.arguments[0]);
         const rest = dcTraceArgsArr(lowerer, call.arguments.slice(1), loc);
-        return { kind: "libCall", fn: "als.exitRun", args: [receiver, fn, rest], type: DYN, loc };
+        return alsTypedResult(lowerer, call, { kind: "libCall", fn: "als.exitRun", args: [receiver, fn, rest], type: DYN, loc });
     }
     if (name === "enterWith" && call.arguments.length === 1) {
         const receiver = lowerer.lowerExprExpecting(access.expression, F64);
@@ -3839,6 +3950,18 @@ export function lowerAlsMethodCall(lowerer, call, access) {
     }
     lowerer.noLowering(`AsyncLocalStorage.${name}`, call, "run(store, fn, ...args), exit(fn, ...args), getStore(), enterWith(store), and disable() are the supported AsyncLocalStorage members", lowerer.checker.getSymbolAtLocation(access.name));
 }
+/** The runtime carries a tagged value, while a typed ALS call promises
+ * its generic store/callback result. Convert at that boundary so inferred
+ * locals and immediate method calls share the same checked representation.
+ * Untyped JS and unknown stores keep the original dynamic value. */
+function alsTypedResult(lowerer, call, value) {
+    const expected = lowerer.mapTypeOf(lowerer.typeOf(call));
+    // Promises already use the runtime's dynamic async path; unlike class
+    // capsules, boxed typed promises do not have a checked extraction ABI.
+    if (!expected || expected.kind === "dyn" || expected.kind === "void" || expected.kind === "promise")
+        return value;
+    return lowerer.coerceInto(call, value, expected);
+}
 /** Property reads on Channel receivers: `.name` (the registration
  * string) and `.hasSubscribers` (the publish guard). Null for
  * non-Channel receivers and other members (the method fence owns them). */
@@ -4184,23 +4307,11 @@ export function strdecHelper(lowerer, op, shapeId, loc) {
     lowerer.liftedFns.push({ name, params, returnType: STRING, locals, body, loc });
     return name;
 }
-/** `JSON.parse(text)` / `JSON.stringify(value)`.
-   * - parse → a may-throw `libCall` producing a dyn value (the runtime JSON
-   *   dyn); malformed input throws a catchable SyntaxError-shaped string.
-   *   The divergence override types the one-argument form `unknown`; the
-   *   lib's reviver form typechecks (returning `any`) and is fenced here.
-   * - stringify → the type-DIRECTED `jsonStringify` node: the lib
-   *   signature honestly says `any`, but lowering requires the argument's
-   *   STATIC IR type to be JSON-safe — the backend emits a per-type
-   *   serializer, never a dynamic walk, so dyn (and closures/class
-   *   instances) are rejected here with a specific message. The
-   *   `stringify(v, null, space)` pretty-print form compiles when the
-   *   replacer is the literal null (or undefined) and the space is a
-   *   LITERAL — Node's rules apply at compile time (numbers clamp to 0–10
-   *   spaces, strings truncate to 10 code units) and the resolved indent
-   *   rides the node to the backend's re-indenter. Function replacers and
-   *   non-literal spaces stay fenced.
-   * Null when this isn't a JSON member call. */
+/** JSON parse produces checked-dynamic data; a native reviver walks it
+ * bottom-up before any checked cast. Stringify without a callback keeps
+ * its type-directed fast path. A function replacer boxes the input and
+ * walks it before primitive normalization. Both paths share literal gap
+ * rules, and callback failures use ordinary native exception unwinding. */
 export function lowerJsonMethodCall(lowerer, call, access) {
     if (call.questionDotToken)
         return null;
@@ -4208,23 +4319,102 @@ export function lowerJsonMethodCall(lowerer, call, access) {
     if (member === null)
         return null;
     const loc = locOf(call);
-    if (member === "parse" && call.arguments.length !== 1) {
-        lowerer.noLowering("JSON.parse with a reviver", call, "parse to `unknown` and validate with a checked cast ('as T') instead");
+    if ((member === "parse" && (call.arguments.length < 1 || call.arguments.length > 2)) ||
+        (member === "stringify" && call.arguments.length > 3) ||
+        call.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`JSON.${member} with extra or spread arguments`, call, "pass the JSON arguments explicitly");
     }
     if (member === "parse") {
         const text = lowerer.lowerExprExpecting(call.arguments[0], STRING);
-        return { kind: "libCall", fn: "json.parse", args: [text], type: DYN, loc };
+        const reviver = call.arguments[1];
+        if (!reviver || jsonNullishArgument(lowerer, reviver)) {
+            return { kind: "libCall", fn: "json.parse", args: [text], type: DYN, loc };
+        }
+        const callback = lowerJsonCallback(lowerer, reviver, "reviver");
+        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);
         }
         const argNode = call.arguments[0];
-        const value = lowerer.lowerExpr(argNode);
+        let value = lowerer.lowerExpr(argNode);
+        // Optional Map/array reads and partially narrowed unions keep their
+        // storage representation when lowered as ordinary arguments. Select
+        // the JSON walker from the proven use-site type, using a checked
+        // conversion so a stale capture cannot read an impossible payload.
+        // Optional strings have a serializer that preserves a missing root;
+        // an unchecked array read can still be absent despite its checker type.
+        if (value.type.kind === "union" && optionalStringTags(lowerer, value.type) === null) {
+            const narrowed = lowerer.mapTypeOf(lowerer.typeOf(argNode));
+            if (narrowed && !isUnitType(narrowed) && narrowed.kind !== "void") {
+                const helper = narrowed.kind === "union"
+                    ? lowerer.narrowedRetagHelper(argNode, value.type.unionId, narrowed.unionId, loc)
+                    : lowerer.narrowedArmHelper(value.type.unionId, narrowed, loc);
+                if (helper)
+                    value = { kind: "call", callee: helper, args: [value], type: narrowed, loc };
+            }
+        }
+        const replacer = call.arguments[1];
+        if (replacer && !jsonNullishArgument(lowerer, replacer)) {
+            const callback = lowerJsonCallback(lowerer, replacer, "replacer");
+            if (value.type.kind === "undefinedT" || value.type.kind === "nullT")
+                value = lowerer.coerceToExpected(value, DYN);
+            // Evaluate the original arguments before taking a typed snapshot.
+            // Creating the callback can itself mutate the input object.
+            const inputSlot = lowerer.declareHiddenLocal("%jsonInput", value.type);
+            const callbackSlot = lowerer.declareHiddenLocal("%jsonCallback", DYN);
+            const boxed = lowerer.coerceToExpected(varRef(inputSlot.id, value.type, loc), DYN);
+            if (boxed.type.kind !== "dyn") {
+                lowerer.unsupported("SC1090", argNode, `JSON.stringify callback input of type '${lowerer.fmt(value.type)}' (the value must cross the checked-dynamic boundary)`);
+            }
+            const raw = {
+                kind: "libCall", fn: "json.stringifyReplacer",
+                args: [boxed, varRef(callbackSlot.id, DYN, loc), { kind: "strLit", value: indent, type: STRING, loc }],
+                type: DYN, loc,
+            };
+            // A replacer can omit even the root. Preserve actual undefined;
+            // an inferred binding adopts this union, while a required string
+            // consumer uses the ordinary checked optional-value boundary.
+            const result = { kind: "dynCheck", value: raw, type: lowerer.withUndefinedArm(STRING), loc };
+            return {
+                kind: "seqExpr", stmts: [
+                    { kind: "varDecl", localId: inputSlot.id, init: value, loc },
+                    { kind: "varDecl", localId: callbackSlot.id, init: callback, loc },
+                ], result, type: result.type, loc,
+            };
+        }
         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))) {
+            // 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 raw = {
+                kind: "libCall", fn: "json.stringifyReplacer",
+                args: [boxed, dynUndefinedExpr(loc), { kind: "strLit", value: indent, type: STRING, loc }],
+                type: DYN, loc,
+            };
+            // Preserve the existing dyn-root string ABI, including its textual
+            // "undefined" result, while letting the runtime honor toJSON hooks.
+            return value.type.kind === "dyn" ? { kind: "toString", operand: raw, type: STRING, loc }
+                : { kind: "dynCheck", value: raw, type: lowerer.withUndefinedArm(STRING), loc };
+        }
         // An ISLAND value (`JSON.stringify(err)` on a package handle — the
         // island error-inspection idiom): the ENGINE's own JSON.stringify
         // runs, so key order, nesting, toJSON, and getters match Node by
@@ -4244,17 +4434,7 @@ export function lowerJsonMethodCall(lowerer, call, access) {
             const raw = { kind: "jsOp", op: "callMethod", name: "stringify", args, type: JSVAL, loc };
             return { kind: "jsOp", op: "toStr", args: [raw], type: STRING, loc };
         }
-        // A dyn ROOT (`JSON.stringify(u)` over unknown / `{}` / `Object` /
-        // `object` slots, the JSON.parse round-trip) serializes with the
-        // runtime's dyn walker instead of a type-directed serializer — the
-        // dyn is JSON-representable by construction (non-JSON values fenced
-        // at their conversion INTO the slot). Two edges, both documented:
-        // a root the stringify drops (runtime undefined) produces the TEXT
-        // "undefined" where Node produces the undefined VALUE (tsc's own lib
-        // types the return `string`, so no static consumer can tell), and a
-        // runtime handle inside the tree throws (Node would walk its own
-        // enumerable props, which the handle does not model).
-        if (!lowerer.jsonStringifySafe(value.type) && value.type.kind !== "dyn") {
+        if (!lowerer.jsonStringifySafe(value.type)) {
             // Bare undefined-armed unions get their own wording: Node's
             // stringify of bare undefined is not a string at all — per-type
             // serialization cannot match that exactly, so the fence is
@@ -4271,16 +4451,47 @@ export function lowerJsonMethodCall(lowerer, call, access) {
                 `(only number, string, boolean, records, arrays, unions of those, and 'unknown' stringify)`);
         }
         const node = { kind: "jsonStringify", value, type: STRING, loc };
-        if (indent !== "") {
-            // The compile-time-resolved indent rides as an extra property (the
-            // node shape in ir/ir.ts is unchanged); the backend re-indents
-            // the compact serializer output with Node's gap algorithm.
+        if (indent !== "")
             node.indent = indent;
-        }
         return node;
     }
     return null; // unknown members are tsc errors before lowering
 }
+/** A valid string/byte overload must select its runtime entry from the live
+ * union tag. Coercing the whole argument to the string overload loses bytes. */
+function lowerStringOrBytesWrite(lowerer, call, dataType, arms, append) {
+    const loc = locOf(call);
+    const key = `fs.${append ? "append" : "write"}:${dataType.unionId}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%fs.writeData.${lowerer.widthHelpers.size}`;
+        lowerer.widthHelpers.set(key, helper);
+        const body = [];
+        for (let tag = 0; tag < arms.length; tag++) {
+            const arm = arms[tag];
+            const fn = arm.kind === "bytes"
+                ? append ? "fs.appendFileSyncBytes" : "fs.writeFileSyncBytes"
+                : append ? "fs.appendFileSync" : "fs.writeFileSync";
+            body.push({ kind: "if", loc,
+                cond: { kind: "unionIsTag", unionId: dataType.unionId, tag, negated: false,
+                    value: varRef("data.0", dataType, loc), type: BOOL, loc },
+                then: [
+                    { kind: "exprStmt", expr: { kind: "libCall", fn, args: [varRef("path.0", STRING, loc),
+                                { kind: "unionNarrow", unionId: dataType.unionId, tag, value: varRef("data.0", dataType, loc), type: arm, loc }], type: VOID, loc }, loc },
+                    { kind: "return", value: null, loc },
+                ], else_: null,
+            });
+        }
+        body.push({ kind: "return", value: null, loc });
+        lowerer.liftedFns.push({ name: helper, returnType: VOID, loc,
+            params: [{ localId: "path.0", name: "path", type: STRING }, { localId: "data.0", name: "data", type: dataType }],
+            locals: [{ id: "path.0", name: "path", type: STRING, mutable: false }, { id: "data.0", name: "data", type: dataType, mutable: false }],
+            body,
+        });
+    }
+    return { kind: "call", callee: helper, args: [lowerer.lowerExprExpecting(call.arguments[0], STRING),
+            lowerer.lowerExprExpecting(call.arguments[1], dataType)], type: VOID, loc };
+}
 function lowerOptionalStringifyRoot(lowerer, value, indent, loc) {
     const tags = optionalStringTags(lowerer, value.type);
     if (!tags || value.type.kind !== "union")
@@ -4323,22 +4534,43 @@ function lowerOptionalStringifyRoot(lowerer, value, indent, loc) {
     }
     return { kind: "call", callee: helper, args: [value], type: resultT, loc };
 }
-/** The compile-time indent of a `JSON.stringify(v[, replacer[, space]])`
-   * call, with Node's space rules applied: a number clamps to 0–10 spaces
-   * (ToInteger truncation), a string truncates to its first 10 code units,
-   * and null/undefined/0/"" mean compact ("" here). Only literal
-   * replacer/space spellings compile — the replacer must be `null` (or
-   * `undefined`), the space a numeric/string literal or `null`/`undefined`;
-   * everything else keeps the existing fence. */
+/** Only explicit null/undefined select the no-callback path. */
+function jsonNullishArgument(lowerer, node) {
+    if (ts.isParenthesizedExpression(node))
+        return jsonNullishArgument(lowerer, node.expression);
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return true;
+    if (!ts.isIdentifier(node) || node.text !== "undefined")
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(node);
+    return symbol !== undefined && lowerer.checker.declarationsOf(symbol).every((decl) => lowerer.isStdlibFile(decl.getSourceFile()));
+}
+/** JSON callbacks cross the same checked native function boundary as other
+ * runtime callbacks. Reviver source contexts need parser source tracking;
+ * 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))) {
+        return { kind: "dynFrom", value: callback, type: DYN, loc: locOf(node) };
+    }
+    lowerer.noLowering(`JSON ${role} of type '${lowerer.fmt(callback.type)}'`, node, "use a native function taking key and value; replacer arrays and reviver source contexts are not supported yet");
+}
+/** Compile-time Node gap rules: numbers clamp to 0–10 spaces and strings
+ * truncate to ten UTF-16 code units. Callback validation is independent. */
 function stringifySpaceIndent(lowerer, call) {
     const fence = () => lowerer.noLowering("JSON.stringify with replacer/space parameters", call, "the serializer is type-directed — shape the value before stringifying");
     if (call.arguments.length <= 1)
         return "";
     const unwrap = (e) => ts.isParenthesizedExpression(e) ? unwrap(e.expression) : e;
-    const isUndefined = (e) => ts.isIdentifier(e) && e.text === "undefined";
-    const replacer = unwrap(call.arguments[1]);
-    if (replacer.kind !== ts.SyntaxKind.NullKeyword && !isUndefined(replacer))
-        fence();
+    const isUndefined = (e) => jsonNullishArgument(lowerer, e);
     if (call.arguments.length === 2)
         return "";
     const space = unwrap(call.arguments[2]);
@@ -4381,6 +4613,8 @@ export function fencedBuiltinImportOf(lowerer, ident) {
         if (ts.isVariableDeclaration(varDecl) && varDecl.initializer !== undefined) {
             const spec = requireSpecOf(varDecl.initializer);
             if (spec !== null) {
+                if (isNativeFfiRequire(lowerer, varDecl.initializer))
+                    return null;
                 const isBuiltin = spec.startsWith("node:") || builtinModules.includes(spec);
                 return isBuiltin && canonicalBuiltinModule(spec) === null ? spec : null;
             }
@@ -4388,9 +4622,9 @@ export function fencedBuiltinImportOf(lowerer, ident) {
     }
     let importDecl;
     if (ts.isImportSpecifier(decl))
-        importDecl = decl.parent.parent.parent;
+        importDecl = decl.parent?.parent?.parent;
     else if (ts.isNamespaceImport(decl))
-        importDecl = decl.parent.parent;
+        importDecl = decl.parent?.parent;
     else if (ts.isImportClause(decl))
         importDecl = decl.parent;
     else
@@ -4765,6 +4999,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 };
     }
@@ -5324,7 +5561,11 @@ export function lowerCryptoHashMethodCall(lowerer, call, access) {
             lowerer.noLowering(`${receiverType.kind === "cryptoHash" ? "Hash" : "Hmac"}.update with ${call.arguments.length} arguments`, call, "update(stringOrBuffer[, inputEncoding]) is supported");
         }
         const dataNode = call.arguments[0];
-        const data = lowerer.lowerExpr(dataNode);
+        const dataType = lowerer.mapTypeOf(lowerer.typeOf(dataNode));
+        // Indexed reads can retain optional storage after a nullish fallback
+        // or narrowing. Use the proven argument type through a checked coercion.
+        const data = dataType?.kind === "string" || dataType?.kind === "bytes"
+            ? lowerer.lowerExprExpecting(dataNode, dataType) : lowerer.lowerExpr(dataNode);
         const prefix = receiverType.kind === "cryptoHash" ? "crypto.hashUpdate" : "crypto.hmacUpdate";
         if (data.type.kind === "bytes" && data.type.elem === "u8") {
             if (call.arguments.length !== 1) {
@@ -5619,7 +5860,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)) {
@@ -5645,7 +5886,33 @@ 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 (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]);
+            }
+            return {
+                kind: "libCall", fn: "child.onDyn",
+                args: [receiver, { kind: "strLit", value: event, type: STRING, loc },
+                    { 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 ())`
@@ -5720,9 +5987,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));
 }
@@ -5862,6 +6129,13 @@ export function lowerProcStreamMethodCall(lowerer, call, access) {
         return null;
     const name = access.name.text;
     const loc = locOf(call);
+    if (isJsSourceFile(call.getSourceFile())) {
+        const receiver = lowerer.lowerExpr(access.expression);
+        if (receiver.type.kind === "dyn") {
+            return { kind: "dynInvoke", recv: receiver, method: name, calleeName: call.expression.getText(),
+                args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc };
+        }
+    }
     if (name === "write" && call.arguments.length === 1) {
         const receiver = lowerer.lowerExpr(access.expression);
         const data = lowerer.lowerExpr(call.arguments[0]);
@@ -5966,7 +6240,8 @@ export function lowerWatcherMethodCall(lowerer, call, access) {
     }
     lowerer.noLowering(`FSWatcher.${name}`, call, "close() is the supported FSWatcher member", lowerer.checker.getSymbolAtLocation(access.name));
 }
-/** `.code` on an error-hierarchy receiver — NodeJS.ErrnoException's
+/** `.code` and `.cause` on an error-hierarchy receiver. The latter reads
+   * the hidden dyn slot installed by constructor options. The former is NodeJS.ErrnoException's
    * member (the fallback declares the same shape): the runtime Error's
    * code slot as `string | undefined` — the errno name where a throw site
    * stamped one (fs, exec spawn/timeout, process.kill, the spawn 'error'
@@ -6000,10 +6275,10 @@ export function lowerErrorCodeProperty(lowerer, expr) {
             return { kind: "libCall", fn: "error.domCause", args: [receiver], type: DYN, loc: locOf(expr) };
         }
     }
-    if (expr.name.text !== "code")
+    if (expr.name.text !== "code" && expr.name.text !== "cause" && expr.name.text !== "stack")
         return null;
     // Error-rooted classes only — builtin or user subclass (both embed the
-    // code slot in their layout prefix).
+    // code and cause slots in their layout prefix).
     let info = lowerer.classes.get(recvT.className) ?? null;
     while (info && info.base)
         info = info.base;
@@ -6014,19 +6289,31 @@ export function lowerErrorCodeProperty(lowerer, expr) {
     const receiver = lowerer.lowerExpr(expr.expression);
     return {
         kind: "libCall",
-        fn: "error.code",
+        fn: expr.name.text === "stack" ? "error.stack" : expr.name.text === "cause" ? "error.cause" : "error.code",
         args: [receiver],
-        type: lowerer.envValueType(),
+        type: expr.name.text === "stack" ? STRING : expr.name.text === "cause" ? DYN : lowerer.envValueType(),
         loc: locOf(expr),
     };
 }
-/** `JSON.parse` / `JSON.stringify` referenced without a call: rejected
-   * specifically, like process methods as values. Null for non-JSON
-   * receivers (the property chain keeps trying other lowerings). */
+/** Stored stringify uses the same native serializer and keeps omitted roots
+   * as undefined. Other JSON method values retain a named refusal. */
 export function lowerJsonProperty(lowerer, expr) {
     const member = lowerer.stdlibGlobalMember(expr, "JSON");
     if (member === null)
         return null;
+    if (member === "stringify") {
+        const loc = locOf(expr);
+        const name = "%builtin.JSON.stringify";
+        if (!lowerer.builtinCallableValueFns.has(name)) {
+            lowerer.builtinCallableValueFns.set(name, name);
+            const params = ["value", "replacer", "space"].map((name) => ({ localId: name, name, type: DYN }));
+            lowerer.liftedFns.push({ name, params, returnType: DYN,
+                locals: params.map((p) => ({ id: p.localId, name: p.name, type: DYN, mutable: false })), loc,
+                body: [{ kind: "return", value: { kind: "libCall", fn: "json.stringifyValue", args: params.map((p) => varRef(p.localId, DYN, loc)), type: DYN, loc }, loc }],
+            });
+        }
+        return { kind: "dynFrom", value: { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN, DYN, DYN], ret: DYN }, loc }, fnName: "stringify", type: DYN, loc };
+    }
     lowerer.unsupported("SC1090", expr, `JSON methods as values (call '${member}' directly)`);
 }
 /** `constants.X_OK` where `constants` is a named fs import: the access-
@@ -6041,10 +6328,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) };
 }
@@ -6066,6 +6353,16 @@ export function lowerProcessStreamProperty(lowerer, expr) {
     if (expr.questionDotToken)
         return null;
     const member = expr.name.text;
+    const direct = ts.isPropertyAccessExpression(expr.expression) ? lowerer.stdlibGlobalMember(expr.expression, "process") : null;
+    if (isJsSourceFile(expr.getSourceFile()) &&
+        (direct === "stdin" || direct === "stdout" || direct === "stderr" ||
+            lowerer.mapTypeOf(lowerer.typeOf(expr.expression))?.kind === "procStream")) {
+        const value = lowerer.lowerExpr(expr.expression);
+        if (value.type.kind === "dyn")
+            return {
+                kind: "dynKeyGet", value, key: strLit(member, locOf(expr.name)), type: DYN, loc: locOf(expr),
+            };
+    }
     if (member !== "isTTY" && member !== "columns" && member !== "rows")
         return null;
     let recv = expr.expression;
@@ -6125,12 +6422,14 @@ export function lowerProcessStreamProperty(lowerer, expr) {
    * rejected specifically. Null for non-process receivers (the chain keeps
    * trying other property lowerings). */
 export function lowerProcessProperty(lowerer, expr) {
-    // process.versions.node — the ONE lowered member of process.versions:
-    // there is no Node under the binary, so the honest answer is the
-    // runtime's own Node compatibility target (the version whose semantics
-    // SEMANTICS.md verifies against — divergence 60, the execPath stance).
-    // Other versions members (v8, openssl, ...) name components that do
-    // not exist here and fall through to the member fence.
+    if (!expr.questionDotToken && expr.name.text === "bigint" && ts.isPropertyAccessExpression(expr.expression) &&
+        lowerer.stdlibGlobalMember(expr.expression, "process") === "hrtime") {
+        const loc = locOf(expr);
+        return { kind: "dynKeyGet", value: { kind: "libCall", fn: "process.hrtimeValue", args: [], type: DYN, loc },
+            key: { kind: "strLit", value: "bigint", type: STRING, loc }, type: DYN, loc };
+    }
+    // node and openssl name the compatibility target, not linked engines.
+    // Read the stable object so descriptor edits through aliases stay visible.
     if ((expr.name.text === "node" || expr.name.text === "openssl") &&
         !expr.questionDotToken &&
         ts.isPropertyAccessExpression(expr.expression) &&
@@ -6140,34 +6439,30 @@ export function lowerProcessProperty(lowerer, expr) {
         // "is crypto available" probe, and the crypto module exists here
         // (unsupported members fence per site). SEMANTICS.md documents that
         // the string names the compat target, not a linked library.
-        const fn = expr.name.text === "node" ? "process.versionsNode" : "process.versionsOpenssl";
-        return { kind: "libCall", fn, args: [], type: STRING, loc: locOf(expr) };
-    }
-    // process.versions?.electron is the runtime-capability probe used by
-    // CLI packages to select Electron argument conventions. versions
-    // itself always exists, and a native scriptc binary is not Electron,
-    // so both the optional and ordinary property spellings read undefined.
+        const loc = locOf(expr);
+        return lowerer.coerceToExpected({
+            kind: "dynKeyGet", key: { kind: "strLit", value: expr.name.text, type: STRING, loc },
+            value: { kind: "libCall", fn: "process.versions", args: [], type: DYN, loc }, type: DYN, loc,
+        }, STRING);
+    }
+    // Other components begin absent. Consult the same object even for the
+    // capability probes: users can define or delete their own entries.
     if (ts.isPropertyAccessExpression(expr.expression) &&
-        lowerer.stdlibGlobalMember(expr.expression, "process") === "versions" &&
-        expr.name.text === "electron") {
-        return { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc: locOf(expr) };
+        lowerer.stdlibGlobalMember(expr.expression, "process") === "versions") {
+        const loc = locOf(expr);
+        return {
+            kind: "dynKeyGet", key: { kind: "strLit", value: expr.name.text, type: STRING, loc },
+            value: { kind: "libCall", fn: "process.versions", args: [], type: DYN, loc }, type: DYN, loc,
+        };
     }
     // The capability-probe members that honestly DON'T EXIST in a
     // compiled binary — each reads undefined (their declared types carry
     // the undefined arm), so feature probes take their documented
-    // fallbacks: no OpenSSL/SQLite components (process.versions.openssl/
-    // .sqlite), no gyp build config (process.config.variables.* — no ICU,
+    // fallbacks: no gyp build config (process.config.variables.* — no ICU,
     // no QUIC — and process.config.target_defaults), no feature flags
     // (process.features.* — no inspector, not a debug build).
     if (!expr.questionDotToken && ts.isPropertyAccessExpression(expr.expression)) {
         const container = lowerer.stdlibGlobalMember(expr.expression, "process");
-        if (container === "versions" && (expr.name.text === "sqlite" || expr.name.text === "bun" || expr.name.text === "deno")) {
-            // versions.bun / versions.deno are the OTHER-runtime probes (a
-            // formatter's config loader picks its package.json reader by
-            // them): a compiled binary is neither, so both read undefined —
-            // exactly Node's own answer.
-            return { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc: locOf(expr) };
-        }
         if (container === "features") {
             return { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc: locOf(expr) };
         }
@@ -6190,6 +6485,18 @@ export function lowerProcessProperty(lowerer, expr) {
     if (member === null)
         return null;
     const loc = locOf(expr);
+    if (member === "versions") {
+        return { kind: "libCall", fn: "process.versions", args: [], type: DYN, loc };
+    }
+    if (member === "hrtime") {
+        return { kind: "libCall", fn: "process.hrtimeValue", args: [], type: DYN, loc };
+    }
+    if (member === "getBuiltinModule") {
+        // Keep the native loader's argument validation when the function is
+        // stored. The declaration's string signature must not insert a checked
+        // adapter before the loader gets to report Node's invalid-id error.
+        return { kind: "dynFrom", value: lowerBuiltinLoaderValue(lowerer, loc), type: DYN, loc };
+    }
     if (member === "argv") {
         return { kind: "libCall", fn: "process.argv", args: [], type: arrayOf(STRING), loc };
     }
@@ -6242,6 +6549,9 @@ export function lowerProcessProperty(lowerer, expr) {
     // procStream scalar, minted as the stream's fd. Member reads
     // (`process.stdout.isTTY`, `.write(...)`) never reach here — their
     // OUTER expressions dispatch first.
+    if (member === "stdin" || ((member === "stdout" || member === "stderr") && isJsSourceFile(expr.getSourceFile()))) {
+        return { kind: "libCall", fn: "process.stdio", args: [numLit(member === "stdin" ? 0 : member === "stdout" ? 1 : 2, loc)], type: DYN, loc };
+    }
     if (member === "stdout" || member === "stderr") {
         return { kind: "numLit", value: member === "stdout" ? 1 : 2, type: PROCSTREAM_T, loc };
     }
@@ -6320,9 +6630,12 @@ function lowerFsReaddirTypesCall(lowerer, call, loc, promiseForm) {
     const callType = lowerer.mapTypeOf(lowerer.typeOf(call));
     if (!callType)
         fence();
-    const result = promiseForm
-        ? callType.kind === "promise" ? callType.inner : fence()
-        : callType;
+    let result = callType;
+    if (promiseForm) {
+        if (callType.kind !== "promise")
+            fence();
+        result = callType.inner;
+    }
     if (result?.kind !== "array" || result.elem.kind !== "record")
         fence();
     const shape = lowerer.shapes.get(result.elem.shapeId);
@@ -6505,9 +6818,10 @@ function lowerQuerystringParseCall(lowerer, call, loc) {
     }
     if (!sawStr || !sawArr)
         fence();
-    const str = call.arguments[0]
-        ? lowerer.lowerExprExpecting(call.arguments[0], STRING)
-        : lowerer.noLowering("querystring.parse without a query string", call);
+    const argument = call.arguments[0];
+    if (!argument)
+        lowerer.noLowering("querystring.parse without a query string", call);
+    const str = lowerer.lowerExprExpecting(argument, STRING);
     const sep = qsSepEqArg(lowerer, call.arguments[1], "&", "querystring.parse", loc);
     const eq = qsSepEqArg(lowerer, call.arguments[2], "=", "querystring.parse", loc);
     // The options walk: maxKeys lowers (Node's rule — > 0 caps the pair
@@ -6679,7 +6993,35 @@ export function lowerProcessEnvGet(lowerer, expr) {
 export function lowerProcessMethodCall(lowerer, call, access) {
     if (call.questionDotToken)
         return null;
+    if (isJsSourceFile(call.getSourceFile()) && ts.isPropertyAccessExpression(access.expression)) {
+        const stream = lowerer.stdlibGlobalMember(access.expression, "process");
+        if (stream === "stdin" || stream === "stdout" || stream === "stderr") {
+            if (call.arguments.some(ts.isSpreadElement))
+                lowerer.noLowering("process stream spread arguments", call);
+            return { kind: "dynInvoke", recv: lowerer.lowerExpr(access.expression), method: access.name.text,
+                calleeName: access.getText(), args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc: locOf(call) };
+        }
+    }
     const directProcessMember = lowerer.stdlibGlobalMember(access, "process");
+    if (directProcessMember === "hrtime") {
+        if (call.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering("process.hrtime with spread arguments", call);
+        const loc = locOf(call);
+        return { kind: "dynCall", callee: { kind: "libCall", fn: "process.hrtimeValue", args: [], type: DYN, loc },
+            args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), calleeName: "process.hrtime", type: DYN, loc };
+    }
+    if (directProcessMember === "getBuiltinModule") {
+        if (call.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering("process.getBuiltinModule with spread arguments", call);
+        const loc = locOf(call);
+        const id = call.arguments[0] ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+            : { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
+        const binding = lowerer.declareHiddenLocal("%builtinId", DYN);
+        return { kind: "seqExpr", stmts: [
+                { kind: "varDecl", localId: binding.id, init: id, loc },
+                ...call.arguments.slice(1).map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc: locOf(arg) })),
+            ], result: { kind: "callValue", callee: lowerBuiltinLoaderValue(lowerer, loc), args: [varRef(binding.id, DYN, loc)], type: DYN, loc }, type: DYN, loc };
+    }
     if (directProcessMember === "send")
         return lowerProcessIpcSend(lowerer, call);
     if (directProcessMember === "disconnect") {
@@ -6935,7 +7277,7 @@ export function lowerProcessMethodCall(lowerer, call, access) {
     if (member === null)
         return null;
     const loc = locOf(call);
-    // process.on/once/off: the CLI event slice — the SIGINT/SIGTERM
+    // process.on/once/off: the CLI event slice — named OS
     // signal handlers and the 'exit' hook. Signal listeners run as
     // macrotasks at loop turns, replace the default disposition while
     // registered (removing the last restores Ctrl-C death), and never
@@ -6966,12 +7308,17 @@ export function lowerProcessMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        // own(), not a bare index: the key is a USER-written event name,
-        // and `{ SIGINT: 2 }["__proto__"]` answers Object.prototype — an
-        // object flowed into a numLit and emitted itself into the C
-        // (test-event-emitter-special-event-names.js's process.on).
-        const SIGNALS = { SIGINT: 2, SIGTERM: 15 };
-        const signo = event !== null ? own(SIGNALS, event) : undefined;
+        if (event === "uncaughtException" || event === "uncaughtExceptionMonitor") {
+            if (!ts.isExpressionStatement(call.parent)) {
+                lowerer.unsupported("SC1090", call, "chaining process exception listener registration");
+            }
+            const cb = dcSubscriberArg(lowerer, call.arguments[1]);
+            const monitor = boolLit(event === "uncaughtExceptionMonitor", loc);
+            return {
+                kind: "libCall", fn: isOff ? "process.offUncaughtException" : "process.onUncaughtException",
+                args: isOff ? [cb, monitor] : [cb, boolLit(member === "once", loc), monitor], type: VOID, loc,
+            };
+        }
         // 'unhandledRejection': the listener crosses as a dyn function and
         // the completed-checkpoint report dispatches it (reason, promise) per
         // never-observed rejection instead of printing and exiting 1
@@ -7007,8 +7354,23 @@ export function lowerProcessMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        if (signo === undefined && event !== "exit") {
-            lowerer.noLowering(`process.${member}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"message", "disconnect", "SIGINT", "SIGTERM", "exit", "warning", "unhandledRejection", and "rejectionHandled" are the supported process events (as literals)');
+        if (event === null || event.startsWith("SIG")) {
+            if (!ts.isExpressionStatement(call.parent)) {
+                lowerer.unsupported("SC1090", call, "chaining process signal listener registration");
+            }
+            const name = lowerer.coerceToExpected(lowerer.lowerExpr(call.arguments[0]), STRING);
+            if (name.type.kind !== "string" && name.type.kind !== "dyn") {
+                lowerer.noLowering("process signal event name that is not a string", call.arguments[0]);
+            }
+            const signal = name.type.kind === "string" ? name : { kind: "dynCheck", value: name, type: STRING, loc };
+            const cb = dcSubscriberArg(lowerer, call.arguments[1]);
+            return {
+                kind: "libCall", fn: isOff ? "process.offSignal" : "process.onSignal",
+                args: isOff ? [signal, cb] : [signal, cb, boolLit(member === "once", loc)], type: VOID, loc,
+            };
+        }
+        if (event !== "exit") {
+            lowerer.noLowering(`process.${member}("${event}", ...)`, call.arguments[0]);
         }
         if (!ts.isExpressionStatement(call.parent)) {
             lowerer.unsupported("SC1090", call, "chaining process listener registration (the result is void here — register each listener as its own statement)");
@@ -7023,7 +7385,7 @@ export function lowerProcessMethodCall(lowerer, call, access) {
         // result; a non-function dyn value throws the catchable TypeError
         // at REGISTRATION (Node's ERR_INVALID_ARG_TYPE moment).
         {
-            const target = funcOf(signo !== undefined || event !== "exit" ? [] : [F64], VOID);
+            const target = funcOf([F64], VOID);
             const exact = cb.type.kind === "func" &&
                 cb.type.ret.kind === "void" &&
                 cb.type.params.length <= 1 &&
@@ -7048,16 +7410,6 @@ export function lowerProcessMethodCall(lowerer, call, access) {
         }
         const param = cb.type.params[0];
         const onceArg = { kind: "boolLit", value: member === "once", type: BOOL, loc };
-        if (signo !== undefined) {
-            if (param !== undefined) {
-                lowerer.unsupported("SC1090", call.arguments[1], "signal listeners with parameters (the signal name argument has no lowering — use ())");
-            }
-            const sig = { kind: "numLit", value: signo, type: F64, loc };
-            if (isOff) {
-                return { kind: "libCall", fn: "process.offSignal", args: [sig, cb], type: VOID, loc };
-            }
-            return { kind: "libCall", fn: "process.onSignal", args: [sig, cb, onceArg], type: VOID, loc };
-        }
         if (param !== undefined && param.kind !== "f64") {
             lowerer.unsupported("SC1090", call.arguments[1], `exit listeners whose parameter is not 'number' (got '${lowerer.fmt(param)}')`);
         }
@@ -7332,7 +7684,7 @@ const NUMBER_STATIC_PREDICATES = {
     isSafeInteger: "number.isSafeInteger",
 };
 /** The Number constants, baked as literals — non-finite ones included
- * (numLits carry NaN and the infinities; both backends spell them). */
+ * (numLits carry NaN and the infinities; the backend preserves them). */
 const NUMBER_CONSTANTS = {
     MAX_SAFE_INTEGER: 9007199254740991,
     MIN_SAFE_INTEGER: -9007199254740991,
@@ -7466,7 +7818,9 @@ export function lowerDateCall(lowerer, call, access) {
     if (call.arguments.length !== 0) {
         lowerer.noLowering(`Date.prototype.${name} with arguments`, call, DATE_METHOD_HINT);
     }
-    const receiver = lowerer.lowerExpr(access.expression);
+    const raw = lowerer.lowerExpr(access.expression);
+    const receiver = raw.type.kind === "dyn"
+        ? { kind: "libCall", fn: "date.checkedValue", args: [raw], type: { kind: "date" }, loc } : raw;
     if (receiver.type.kind !== "date")
         lowerer.badType(access.expression, lowerer.typeOf(access.expression));
     if (name === "getTime" || name === "valueOf") {
@@ -7487,78 +7841,124 @@ export function lowerDateCall(lowerer, call, access) {
     }
     lowerer.noLowering(`Date.prototype.${name}`, call, DATE_METHOD_HINT, lowerer.checker.getSymbolAtLocation(access.name));
 }
-/* WHATWG label registry → native decoder id. The first 27 ids stay in the
- * same order as scripts/gen-text-decoder-tables.mjs; the remaining ids match
- * scr_bytes.c's compact enum. ISO-8859-8-I shares ISO-8859-8's byte table,
- * and GBK/gb18030 share one decoder (their decoders are identical). */
-const TEXT_DECODER_SINGLE_BYTE_NAMES = [
-    "ibm866", "iso-8859-2", "iso-8859-3", "iso-8859-4", "iso-8859-5",
-    "iso-8859-6", "iso-8859-7", "iso-8859-8", "iso-8859-10", "iso-8859-13",
-    "iso-8859-14", "iso-8859-15", "iso-8859-16", "koi8-r", "koi8-u",
-    "macintosh", "windows-874", "windows-1250", "windows-1251", "windows-1252",
-    "windows-1253", "windows-1254", "windows-1255", "windows-1256", "windows-1257",
-    "windows-1258", "x-mac-cyrillic",
-];
-const TEXT_DECODER_UTF8_LABELS = new Set([
-    "unicode-1-1-utf-8", "unicode11utf8", "unicode20utf8", "utf-8", "utf8", "x-unicode20utf8",
-]);
-const TEXT_DECODER_LEGACY_LABELS = (() => {
-    const labels = Object.create(null);
-    const add = (encoding, names) => {
-        for (const name of names)
-            labels[name] = encoding;
+/** Box a codec's immutable encoding in an owned record. Unlike erased
+ * aliases, this value can live in fields, arguments, and closure captures. */
+export function lowerTextCodecNew(lowerer, ctor, cls) {
+    const args = ctor.arguments ?? [];
+    const loc = locOf(ctor);
+    let encoding = { kind: "numLit", value: -1, type: F64, loc };
+    let label = null;
+    if (cls === "TextEncoder") {
+        if (args.length !== 0)
+            lowerer.noLowering("new TextEncoder with arguments", ctor);
+    }
+    else if (args.length !== 0) {
+        const labelT = lowerer.typeOf(args[0]);
+        const parsed = labelT.isStringLiteralType() ? staticTextDecoderEncoding(labelT.value) : null;
+        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));
+        }
+    }
+    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: encoding }, ...(cls === "TextDecoder" ? [
+                ...[...flags].map(([name, value]) => ({ name: `%${name}`, value })),
+                { name: "%state", value: { kind: "dynObjLit", fields: [], type: DYN, loc } },
+            ] : [])], type, loc,
     };
-    const single = (name, aliases) => {
-        add(TEXT_DECODER_SINGLE_BYTE_NAMES.indexOf(name), aliases);
+    return label === null || label.kind === "strLit" ? result : {
+        kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: label, loc }], result, type, loc,
     };
-    single("ibm866", ["866", "cp866", "csibm866", "ibm866"]);
-    single("iso-8859-2", ["csisolatin2", "iso-8859-2", "iso-ir-101", "iso8859-2", "iso88592", "iso_8859-2", "iso_8859-2:1987", "l2", "latin2"]);
-    single("iso-8859-3", ["csisolatin3", "iso-8859-3", "iso-ir-109", "iso8859-3", "iso88593", "iso_8859-3", "iso_8859-3:1988", "l3", "latin3"]);
-    single("iso-8859-4", ["csisolatin4", "iso-8859-4", "iso-ir-110", "iso8859-4", "iso88594", "iso_8859-4", "iso_8859-4:1988", "l4", "latin4"]);
-    single("iso-8859-5", ["csisolatincyrillic", "cyrillic", "iso-8859-5", "iso-ir-144", "iso8859-5", "iso88595", "iso_8859-5", "iso_8859-5:1988"]);
-    single("iso-8859-6", ["arabic", "asmo-708", "csiso88596e", "csiso88596i", "csisolatinarabic", "ecma-114", "iso-8859-6", "iso-8859-6-e", "iso-8859-6-i", "iso-ir-127", "iso8859-6", "iso88596", "iso_8859-6", "iso_8859-6:1987"]);
-    single("iso-8859-7", ["csisolatingreek", "ecma-118", "elot_928", "greek", "greek8", "iso-8859-7", "iso-ir-126", "iso8859-7", "iso88597", "iso_8859-7", "iso_8859-7:1987", "sun_eu_greek"]);
-    single("iso-8859-8", ["csiso88598e", "csiso88598i", "csisolatinhebrew", "hebrew", "iso-8859-8", "iso-8859-8-e", "iso-8859-8-i", "iso-ir-138", "iso8859-8", "iso88598", "iso_8859-8", "iso_8859-8:1988", "logical", "visual"]);
-    single("iso-8859-10", ["csisolatin6", "iso-8859-10", "iso-ir-157", "iso8859-10", "iso885910", "l6", "latin6"]);
-    single("iso-8859-13", ["iso-8859-13", "iso8859-13", "iso885913"]);
-    single("iso-8859-14", ["iso-8859-14", "iso8859-14", "iso885914"]);
-    single("iso-8859-15", ["csisolatin9", "iso-8859-15", "iso8859-15", "iso885915", "iso_8859-15", "l9"]);
-    single("iso-8859-16", ["iso-8859-16"]);
-    single("koi8-r", ["cskoi8r", "koi", "koi8", "koi8-r", "koi8_r"]);
-    single("koi8-u", ["koi8-ru", "koi8-u"]);
-    single("macintosh", ["csmacintosh", "mac", "macintosh", "x-mac-roman"]);
-    single("windows-874", ["dos-874", "iso-8859-11", "iso8859-11", "iso885911", "tis-620", "windows-874"]);
-    single("windows-1250", ["cp1250", "windows-1250", "x-cp1250"]);
-    single("windows-1251", ["cp1251", "windows-1251", "x-cp1251"]);
-    single("windows-1252", ["ansi_x3.4-1968", "ascii", "cp1252", "cp819", "csisolatin1", "ibm819", "iso-8859-1", "iso-ir-100", "iso8859-1", "iso88591", "iso_8859-1", "iso_8859-1:1987", "l1", "latin1", "us-ascii", "windows-1252", "x-cp1252"]);
-    single("windows-1253", ["cp1253", "windows-1253", "x-cp1253"]);
-    single("windows-1254", ["cp1254", "csisolatin5", "iso-8859-9", "iso-ir-148", "iso8859-9", "iso88599", "iso_8859-9", "iso_8859-9:1989", "l5", "latin5", "windows-1254", "x-cp1254"]);
-    single("windows-1255", ["cp1255", "windows-1255", "x-cp1255"]);
-    single("windows-1256", ["cp1256", "windows-1256", "x-cp1256"]);
-    single("windows-1257", ["cp1257", "windows-1257", "x-cp1257"]);
-    single("windows-1258", ["cp1258", "windows-1258", "x-cp1258"]);
-    single("x-mac-cyrillic", ["x-mac-cyrillic", "x-mac-ukrainian"]);
-    add(27, ["x-user-defined"]);
-    add(28, ["csunicode", "iso-10646-ucs-2", "ucs-2", "unicode", "unicodefeff", "utf-16", "utf-16le"]);
-    add(29, ["unicodefffe", "utf-16be"]);
-    add(30, ["chinese", "csgb2312", "csiso58gb231280", "gb18030", "gb2312", "gb_2312", "gb_2312-80", "gbk", "iso-ir-58", "x-gbk"]);
-    add(31, ["big5", "big5-hkscs", "cn-big5", "csbig5", "x-x-big5"]);
-    add(32, ["cseucpkdfmtjapanese", "euc-jp", "x-euc-jp"]);
-    add(33, ["csiso2022jp", "iso-2022-jp"]);
-    add(34, ["csshiftjis", "ms932", "ms_kanji", "shift-jis", "shift_jis", "sjis", "windows-31j", "x-sjis"]);
-    add(35, ["cseuckr", "csksc56011987", "euc-kr", "iso-ir-149", "korean", "ks_c_5601-1987", "ks_c_5601-1989", "ksc5601", "ksc_5601", "windows-949"]);
-    return labels;
-})();
-/** TextDecoder's get-an-encoding normalization: trim ASCII whitespace and
- * fold ASCII case only (Unicode case folding must not manufacture a label). */
-function staticTextDecoderEncoding(label) {
-    const normalized = label
-        .replace(/^[\u0009\u000a\u000c\u000d\u0020]+|[\u0009\u000a\u000c\u000d\u0020]+$/g, "")
-        .replace(/[A-Z]/g, (char) => char.toLowerCase());
-    if (TEXT_DECODER_UTF8_LABELS.has(normalized))
-        return { kind: "utf8" };
-    const id = own(TEXT_DECODER_LEGACY_LABELS, normalized);
-    return id === undefined ? null : { kind: "legacy", id };
+}
+function storedTextCodecClassOf(lowerer, expr) {
+    const sym = lowerer.typeOf(expr).getSymbol();
+    if (!sym || (sym.name !== "TextEncoder" && sym.name !== "TextDecoder"))
+        return null;
+    return lowerer.checker.declarationsOf(sym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) && lowerer.isStdlibFile(d.getSourceFile())) ? sym.name : null;
+}
+function lowerStoredTextCodecCall(lowerer, call, access) {
+    const cls = storedTextCodecClassOf(lowerer, access.expression);
+    if (cls === null || !lowerer.isStdlibMember(access))
+        return null;
+    if (access.name.text !== (cls === "TextEncoder" ? "encode" : "decode"))
+        return null;
+    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));
+    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)");
+    }
+    const key = `textCodec.${cls}.${receiver.type.shapeId}`;
+    let name = lowerer.widthHelpers.get(key);
+    if (!name) {
+        name = `%${key}`;
+        lowerer.widthHelpers.set(key, name);
+        const recT = receiver.type;
+        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: "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 }, { 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 }, { id: "stream.0", name: "stream", type: BOOL, mutable: false }],
+            body: [{ kind: "return", value: result, loc }], 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
@@ -7579,118 +7979,8 @@ function directTextCodecCtorOf(lowerer, expr) {
         return null;
     return { cls: sym.name, ctor };
 }
-/** True when construction itself is effect-free and inside the already
-   * lowered codec slice, so a const binding can be erased and calls can
-   * resolve back to the initializer. TextDecoder's explicit label must be
-   * an actual recognized literal here: accepting an arbitrary expression
-   * merely typed as a label would move or repeat its effects when the
-   * binding is erased. */
-function erasableTextCodecCtor(info) {
-    const args = info.ctor.arguments ?? [];
-    if (info.cls === "TextEncoder")
-        return args.length === 0;
-    if (args.length === 0)
-        return true;
-    if (args.length !== 1)
-        return false;
-    const label = stripTypeCasts(args[0]);
-    return ts.isStringLiteralLike(label) && staticTextDecoderEncoding(label.text) !== null;
-}
-/** `const encoder = new TextEncoder()` / a statically-labelled TextDecoder twin:
-   * compile-time alias plumbing with no runtime object. Calls through the
-   * stable binding are recognized by textCodecReceiverOf below; any other
-   * reached value use keeps the ordinary SC2020 representation fence. Both
-   * declaration walks call this and independently gate on constness. */
-export function textCodecBindingClassOf(lowerer, nameNode, init) {
-    if (!ts.isIdentifier(nameNode) || init === undefined)
-        return null;
-    const decl = nameNode.parent;
-    if (!ts.isVariableDeclaration(decl) || !ts.isVariableDeclarationList(decl.parent) ||
-        !ts.isVariableStatement(decl.parent.parent)) {
-        return null;
-    }
-    const info = directTextCodecCtorOf(lowerer, init);
-    return info !== null && erasableTextCodecCtor(info) ? info.cls : null;
-}
-export function textCodecBindingDecl(lowerer, nameNode, init) {
-    return textCodecBindingClassOf(lowerer, nameNode, init) !== null;
-}
-/** The inline composed receiver, or a const identifier whose initializer
-   * is an erasable codec construction in the same execution scope and
-   * after that declaration. Following the declaration instead of
-   * materializing the value is honest for the supported slice: receiver
-   * reads are pure, construction has no effects, and every non-call use
-   * fences because there is deliberately no general value lowering. */
-function textCodecReceiverOf(lowerer, expr) {
-    const direct = directTextCodecCtorOf(lowerer, expr);
-    if (direct !== null)
-        return direct;
-    const receiver = stripTypeCasts(expr);
-    if (!ts.isIdentifier(receiver))
-        return null;
-    const sym = lowerer.resolveValueSymbol(receiver);
-    const decl = sym ? lowerer.checker.valueDeclarationOf(sym) : undefined;
-    if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined ||
-        !ts.isVariableDeclarationList(decl.parent) || (decl.parent.flags & ts.NodeFlags.Const) === 0 ||
-        !textCodecBindingDecl(lowerer, decl.name, decl.initializer)) {
-        return null;
-    }
-    // A closure can run before the const initializes (TDZ), and an
-    // imported binding can be observed during a module cycle; both need
-    // real runtime storage rather than this deliberately trivial rewrite.
-    const executionScope = (node) => {
-        let child = node;
-        for (let cur = node.parent;; child = cur, cur = cur.parent) {
-            if (ts.isFunctionLike(cur) || ts.isSourceFile(cur))
-                return cur;
-            // An instance field initializer runs when an object is constructed,
-            // not when its enclosing class expression evaluates. Treat it like
-            // a closure boundary: a later source position does not prove the
-            // codec declaration ran (a switch can enter a following case and
-            // instantiate the class while the binding is still in its TDZ).
-            if (ts.isPropertyDeclaration(cur) && cur.initializer === child &&
-                (ts.getCombinedModifierFlags(cur) & ts.ModifierFlags.Static) === 0) {
-                return cur;
-            }
-        }
-    };
-    if (executionScope(receiver) !== executionScope(decl) || receiver.getStart() < decl.end)
-        return null;
-    // All switch clauses share one lexical environment, but dispatch can
-    // enter a later clause without executing a const in an earlier one.
-    // TypeScript normally diagnoses the direct read; an @ts-expect-error
-    // can deliberately retain the runtime TDZ shape, so source order alone
-    // is not a sufficient proof. A codec declared in a clause is erasable
-    // only for uses inside that exact clause's subtree (nested switches are
-    // fine; closures and instance initializers already fail executionScope).
-    const switchClauseOf = (node) => {
-        for (let cur = node.parent; cur !== undefined; cur = cur.parent) {
-            if (ts.isCaseClause(cur) || ts.isDefaultClause(cur))
-                return cur;
-            if (ts.isFunctionLike(cur) || ts.isSourceFile(cur))
-                return null;
-        }
-        return null;
-    };
-    const declClause = switchClauseOf(decl);
-    if (declClause !== null) {
-        let insideDeclClause = false;
-        for (let cur = receiver; cur !== undefined; cur = cur.parent) {
-            if (cur === declClause) {
-                insideDeclClause = true;
-                break;
-            }
-        }
-        if (!insideDeclClause)
-            return null;
-    }
-    return directTextCodecCtorOf(lowerer, decl.initializer);
-}
-/** The WHATWG encoder pair, COMPOSED or through an erasable const binding:
-   * `new TextDecoder().decode(bytes)`, `new TextEncoder().encode(s)`, and
-   * the idiomatic store-then-call equivalents. The codec object never
-   * exists (the crypto/Date precedent); bare construction and value uses
-   * are fenced with the composed hint. decode is the runtime's WHATWG
+/** Inline codec calls avoid allocating a receiver; stored receivers use
+   * the owned record path above. decode is the runtime's WHATWG
    * decode for every recognized static label (with BOM handling for the
    * Unicode encodings); a zero-argument decode() is "" like the spec's.
    * encode IS Buffer.from(s, "utf8") — ScrStr
@@ -7703,10 +7993,14 @@ export function lowerTextCodecCall(lowerer, call, access) {
     const member = access.name.text;
     if (member !== "decode" && member !== "encode")
         return null;
-    const info = textCodecReceiverOf(lowerer, access.expression);
-    if (info === null || !lowerer.isStdlibMember(access))
+    const info = directTextCodecCtorOf(lowerer, access.expression);
+    if (info === null)
+        return lowerStoredTextCodecCall(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;
     }
@@ -7715,7 +8009,7 @@ export function lowerTextCodecCall(lowerer, call, access) {
     if (cls === "TextDecoder") {
         // The label must be statically known. A literal-typed effectful inline
         // expression is accepted, but its evaluation is sequenced before the
-        // decode below; stored decoder aliases admit only actual literals.
+        // decode below, just as stored decoders evaluate it at construction.
         const labelT = ctorArgs.length >= 1 ? lowerer.typeOf(ctorArgs[0]) : null;
         const encoding = ctorArgs.length === 0
             ? { kind: "utf8" }
@@ -7723,7 +8017,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)
@@ -7745,7 +8039,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)");
         }
@@ -7763,23 +8060,23 @@ export function lowerTextCodecCall(lowerer, call, access) {
     if (ctorArgs.length > 0) {
         lowerer.noLowering("new TextEncoder with arguments", recv);
     }
-    if (call.arguments.length !== 1) {
-        lowerer.noLowering(`TextEncoder.encode with ${call.arguments.length} arguments`, call, call.arguments.length === 0 ? "pass the string (a zero-argument encode is an empty Uint8Array)" : undefined);
+    if (call.arguments.length > 1) {
+        lowerer.noLowering(`TextEncoder.encode with ${call.arguments.length} arguments`, call);
     }
-    const s = lowerer.lowerExprExpecting(call.arguments[0], STRING);
+    const s = call.arguments.length === 0 ? strLit("", loc) : lowerer.lowerExprExpecting(call.arguments[0], STRING);
     const enc = { kind: "strLit", value: "utf8", type: STRING, loc };
     return { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
 }
-/** `String.fromCharCode(...codes)` on THE String global: every argument
+/** `String.fromCharCode/fromCodePoint(...codes)` on THE String global: every argument
    * lowers as a number and packs into ONE f64[] array-literal argument
    * (the path.join convention) — or ONE whole-array spread forwards the
-   * array itself. Other String statics (fromCodePoint, raw) fall through
-   * to the member fence. Null for non-String receivers. */
+   * array itself. String.raw has its own template path below.
+   * Null for non-String receivers. */
 export function lowerStringStaticCall(lowerer, call, access) {
     if (call.questionDotToken)
         return null;
     const member = lowerer.stdlibGlobalMember(access, "String");
-    if (member !== "fromCharCode" && member !== "raw")
+    if (member !== "fromCharCode" && member !== "fromCodePoint" && member !== "raw")
         return null;
     const loc = locOf(call);
     // String.raw(template, ...substitutions): the template's `raw` member
@@ -7823,7 +8120,7 @@ export function lowerStringStaticCall(lowerer, call, access) {
     const spread = call.arguments.find(ts.isSpreadElement);
     if (spread) {
         if (call.arguments.length !== 1) {
-            lowerer.noLowering("String.fromCharCode with a mixed spread call", call, "spread a whole array (String.fromCharCode(...codes)) or pass plain arguments");
+            lowerer.noLowering(`String.${member} with a mixed spread call`, call, `spread a whole array (String.${member}(...codes)) or pass plain arguments`);
         }
         // A typed-array/Buffer spread (String.fromCharCode(...data.slice(4, 8))
         // — the magic-number ASCII probe) passes the bytes value through; the
@@ -7833,14 +8130,14 @@ export function lowerStringStaticCall(lowerer, call, access) {
             const packed = lowerer.lowerExpr(spread.expression);
             if (packed.type.kind !== "bytes")
                 lowerer.badType(spread.expression, lowerer.typeOf(spread.expression));
-            return { kind: "libCall", fn: "string.fromCharCode", args: [packed], type: STRING, loc };
+            return { kind: "libCall", fn: `string.${member}`, args: [packed], type: STRING, loc };
         }
         const packed = lowerer.lowerExprExpecting(spread.expression, arrayOf(F64));
-        return { kind: "libCall", fn: "string.fromCharCode", args: [packed], type: STRING, loc };
+        return { kind: "libCall", fn: `string.${member}`, args: [packed], type: STRING, loc };
     }
     const elems = call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64));
     const packed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-    return { kind: "libCall", fn: "string.fromCharCode", args: [packed], type: STRING, loc };
+    return { kind: "libCall", fn: `string.${member}`, args: [packed], type: STRING, loc };
 }
 /** `s.lastIndexOf(searchValue?, position?)` on string receivers, using UTF-16
    * indices. An omitted search value searches for "undefined". Omitted or undefined positions clamp to the string's end;
@@ -7973,7 +8270,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));
@@ -8006,7 +8303,7 @@ export function lowerPromiseStaticCall(lowerer, call, access) {
         // 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 {
@@ -8182,11 +8479,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
@@ -8206,6 +8504,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;
@@ -8316,14 +8617,24 @@ export function isConsoleLog(lowerer, call) {
    * like every stdlib global. Null for anything else (console.table, a
    * user's own console binding, ...). */
 export function consoleCallMember(lowerer, call) {
+    if (call.questionDotToken)
+        return null;
+    if (ts.isIdentifier(call.expression)) {
+        const imported = builtinImportOf(lowerer, call.expression);
+        return imported?.module === "console" && isConsoleOutputMember(imported.member) ? imported.member : null;
+    }
     if (!ts.isPropertyAccessExpression(call.expression))
         return null;
     const access = call.expression;
     if (access.questionDotToken || call.questionDotToken)
         return null;
     const name = access.name.text;
-    if (name !== "log" && name !== "info" && name !== "debug" && name !== "error" && name !== "warn")
+    if (!isConsoleOutputMember(name))
         return null;
-    return lowerer.isStdlibGlobal(access.expression, "console") ? name : null;
+    return lowerer.isStdlibGlobal(access.expression, "console") ||
+        lowerer.builtinNamespaceModuleOf(access.expression) === "console" ? name : null;
+}
+function isConsoleOutputMember(name) {
+    return name === "log" || name === "info" || name === "debug" || name === "error" || name === "warn";
 }
 //# sourceMappingURL=lower-builtins.js.map