@scriptc/compiler 0.1.7 → 0.2.0

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
@@ -7,7 +8,7 @@ import { builtinModules } from "node:module";
 import { dirname, isAbsolute, resolve } from "node:path";
 import * as ts from "../ts7/adapter.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 +25,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 +126,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 +149,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 +161,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 +208,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 +218,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 +258,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 +382,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 +396,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 +426,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 +445,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
@@ -456,7 +481,7 @@ export function createRequireProgramModuleOf(lowerer, expr) {
     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);
+        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 +592,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 +613,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 +712,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 +725,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 +789,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 +807,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 +889,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
@@ -1300,6 +1335,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`);
@@ -1979,15 +2039,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 +2211,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 +2251,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 };
         }
@@ -3813,20 +3902,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 +3928,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 +4285,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,12 +4297,19 @@ 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 indent = stringifySpaceIndent(lowerer, call);
@@ -4221,10 +4317,70 @@ export function lowerJsonMethodCall(lowerer, call, access) {
             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 +4400,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 +4417,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 +4500,37 @@ 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 === "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 +4573,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 +4582,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
@@ -5324,7 +5518,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) {
@@ -5862,6 +6060,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 +6171,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 +6206,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 +6220,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-
@@ -6066,6 +6284,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 +6353,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 +6370,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 +6416,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 +6480,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 +6561,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 +6749,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 +6924,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 +7208,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 +7239,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 +7285,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 +7316,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 +7341,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 +7615,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 +7749,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 +7772,87 @@ 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 = -1;
+    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 !== 1 || parsed === null) {
+            lowerer.noLowering("new TextDecoder with runtime-valued options or an unknown label", ctor, "a recognized literal WHATWG label with default options compiles");
+        }
+        encoding = parsed.kind === "utf8" ? -1 : parsed.id;
+        label = lowerer.lowerExprExpecting(args[0], STRING);
+    }
+    const type = lowerer.mapTypeOf(lowerer.typeOf(ctor));
+    if (type?.kind !== "record")
+        lowerer.badType(ctor, lowerer.typeOf(ctor));
+    const result = {
+        kind: "recordLit", fields: [{ name: `%${cls}`, value: { kind: "numLit", value: encoding, type: F64, loc } }], type, loc,
     };
-    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 > 1) {
+        lowerer.noLowering(cls === "TextDecoder" ? "decode with a stream option" : "TextEncoder.encode with extra arguments", call);
+    }
+    const loc = locOf(call);
+    const receiver = lowerer.lowerExpr(access.expression);
+    if (receiver.type.kind !== "record")
+        lowerer.badType(access.expression, lowerer.typeOf(access.expression));
+    const arg = call.arguments.length === 0
+        ? 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 === "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: "ternary",
+                cond: { kind: "bin", op: "<", left: { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc }, right: { kind: "numLit", value: 0, type: F64, loc }, type: BOOL, loc },
+                then: { kind: "libCall", fn: "text.decode", args: [input], type: STRING, loc },
+                else_: { kind: "libCall", fn: "text.decodeLegacy", args: [input, { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc }], type: STRING, loc },
+                type: STRING, loc,
+            };
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "codec.0", name: "codec", type: recT }, { localId: "input.0", name: "input", type: arg.type }],
+            returnType: result.type,
+            locals: [{ id: "codec.0", name: "codec", type: recT, mutable: false }, { id: "input.0", name: "input", type: arg.type, mutable: false }],
+            body: [{ kind: "return", value: result, loc }], loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [receiver, arg], 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 +7873,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,8 +7887,10 @@ 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" && member === "decode") && !(cls === "TextEncoder" && member === "encode")) {
@@ -7715,7 +7901,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" }
@@ -7763,23 +7949,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 +8009,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 +8019,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;
@@ -8316,14 +8502,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