@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,6 +1,11 @@
+import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js";
+import { adaptPromiseExecutor } from "./promise-executor-adapter.js";
 import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js";
+import { constructedFromValue, constructedValue, superIntoResultSlot, } from "./constructor-returns.js";
 import { checkedIterableSpread } from "./checked-iterable-spread.js";
 import { lowerReadlineUiNew } from "./builtins/readline.js";
+import { builtinMemberRequireDecl } from "./builtins/module-bindings.js";
+import { checkedClassUnionAssertion } from "./class-assertions.js";
 import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
@@ -9,40 +14,48 @@ import { InternalCompilerError } from "../../errors.js";
  * accessor access, upcasts, `new` expressions, and the builtin Error
  * hierarchy registration. */
 import { fsStreamClassOf, lowerFsStreamNew } from "./builtins/fs-streams.js";
+import { codeGenerationCalleeOf, lowerCodeGenerationCall } from "./code-generation.js";
+import { TEMPORAL_GLOBAL } from "../builtin-modules.js";
 import * as ts from "../ts7/adapter.js";
-import { lowerZlibStreamNew, zlibStreamModeOf } from "./builtins/compression.js";
-import { BOOL, DATE_T, DYN, F64, bytesOf, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
-import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, } from "./generic-functions.js";
+import { lowerZlibStreamNew, zlibClassName, zlibStreamModeOf } from "./builtins/compression.js";
+import { everyStmtList } from "../../ir/traverse.js";
+import { builtinClassAliasOf, builtinClassRefOf, } from "./builtins/class-values.js";
+import { inlineNamespaceRequireOf, lowerWithInlineRequireInit } from "./cjs-inline-require.js";
+import { BOOL, canDynCheckTo, DATE_T, DYN, F64, bytesOf, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, classValueConstructor, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
+import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, genericLocalClassResult, } from "./generic-functions.js";
 import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
 import { appendImplicitUndefinedReturn, hasExplicitJsDocReturn } from "./function-returns.js";
 import { bodyReadsArguments } from "../arguments-usage.js";
-import { generatorMeta } from "./call-signatures.js";
+import { errorNameAfterField, errorViewFields } from "./error-name-order.js";
+import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, } from "./call-signatures.js";
 import { omittedArgFor } from "./call-arguments.js";
 import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
-import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf, } from "../program.js";
-import { PoisonError, dynFallbackType, newFnCtx, own } from "./lowerer.js";
+import { canonicalBuiltinModule, cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, locOf, requireSpecOf, } from "../program.js";
+import { PoisonError, dynFallbackType, jsFuncNameOf, newFnCtx, own } from "./lowerer.js";
 import { isAssertClassNew } from "./assert-instances.js";
+import { isCjsRequireGlobal } from "./lower-node-module.js";
 import { lowerArrayConstructor } from "./containers/array-construction.js";
 import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
 import { lowerObjectConstructor } from "./containers/indexed-objects.js";
-import { bufEncoding } from "./containers/bytes.js";
+import { knownBufEncoding, lowerNodeModulesBufferConstruct } from "./containers/bytes.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { lowerSearchParamsNew } from "./builtins/url.js";
 import { lowerTextCodecNew } from "./builtins/text-codecs.js";
-import { lowerMessageChannelNew, lowerWorkerNew } from "./builtins/workers.js";
+import { lowerBroadcastChannelNew, lowerMessageChannelNew, lowerWorkerNew, } from "./builtins/workers.js";
 import { unsupportedPackageValueDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.js";
-import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
+import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, STREAM_COMPLETION_CALLBACK_INDEX, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
 import { builtinEventTargetBaseOf, eventTargetApiMembers, eventTargetApiMethod, eventTargetRootOf, eventTargetSuperCall, lowerEventTargetMethodCall, } from "./lower-event-target.js";
 import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall, } from "./lower-event-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js";
 import { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js";
-import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
+import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
 import { hasLexicalPrivateReference, hasStaticThis, rejectStaticThis } from "./static-this.js";
 import { lowerUrlNew } from "./lower-url.js";
 import { isNativeProxyInitializer, lowerNativeProxy } from "./expressions/native-proxy.js";
 import { classStaticDataFor } from "./class-static-data.js";
+import { construction, constructionPrefix } from "./js-class-fields.js";
 import { lowerObjectFactoryNew } from "./object-factory-new.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.js";
@@ -53,7 +66,7 @@ import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-sta
 import { reflectedClassStaticMethodValue } from "./class-method-values.js";
 export function returnsOnlyThis(member) {
     const body = member.body;
-    const last = body?.statements.at(-1);
+    const last = body?.statements?.nodes.at(-1);
     if (!body || !last || !ts.isReturnStatement(last))
         return false;
     let valid = true;
@@ -67,9 +80,43 @@ export function returnsOnlyThis(member) {
             if (!value || value.kind !== ts.SyntaxKind.ThisKeyword)
                 valid = false;
         }
-        node.forEachChild(visit);
+        ts.forEachChild(node, visit);
     };
-    body.forEachChild(visit);
+    ts.forEachChild(body, visit);
+    return valid;
+}
+/** returnsOnlyThis, also accepting a comma expression whose last operand
+ * is `this` (the minifier's `return a(), this.x = v, this`, jose's fluent
+ * claim setters). Used only to narrow a call's result back to the
+ * receiver's class. */
+export function returnsOnlyThisValue(member) {
+    const body = member.body;
+    const last = body?.statements?.nodes.at(-1);
+    if (!body || !last || !ts.isReturnStatement(last))
+        return false;
+    let valid = true;
+    const visit = (node) => {
+        if (ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node)) {
+            let value = node.expression;
+            for (;;) {
+                while (value && ts.isParenthesizedExpression(value))
+                    value = value.expression;
+                if (value &&
+                    ts.isBinaryExpression(value) &&
+                    value.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+                    value = value.right;
+                    continue;
+                }
+                break;
+            }
+            if (!value || value.kind !== ts.SyntaxKind.ThisKeyword)
+                valid = false;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(body, visit);
     return valid;
 }
 function functionLocalClass(decl) {
@@ -107,9 +154,7 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
             return stored.type;
         const symbol = lowerer.resolveValueSymbol(expression);
         const declaration = symbol &&
-            lowerer.checker
-                .declarationsOf(symbol)
-                .find((decl) => ts.isVariableDeclaration(decl) &&
+            symbol.declarations.find((decl) => ts.isVariableDeclaration(decl) &&
                 decl.initializer &&
                 (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0);
         if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
@@ -118,11 +163,17 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
                 return value;
         }
     }
+    // A generic factory's own local class has one class per instance.
+    if (ts.isCallExpression(expression)) {
+        const local = genericLocalClassResult(lowerer, expression);
+        if (local?.kind === "classval")
+            return local;
+    }
     const type = lowerer.typeOf(expression);
     const mapped = lowerer.mapTypeOf(type);
     if (mapped?.kind === "classval" && !lowerer.classes.has(mapped.className)) {
         for (const signature of lowerer.checker.getConstructSignatures(type)) {
-            const constructor = lowerer.checker.signatureDeclaration(signature);
+            const constructor = signature.declaration;
             const declaration = constructor && ts.isConstructorDeclaration(constructor) ? constructor.parent : undefined;
             if (declaration &&
                 ts.isClassExpression(declaration) &&
@@ -161,9 +212,7 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
         if (ts.isIdentifier(callee)) {
             const symbol = lowerer.resolveValueSymbol(callee);
             const declaration = symbol &&
-                lowerer.checker
-                    .declarationsOf(symbol)
-                    .find((decl) => ts.isVariableDeclaration(decl) &&
+                symbol.declarations.find((decl) => ts.isVariableDeclaration(decl) &&
                     decl.initializer &&
                     (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0);
             if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
@@ -174,8 +223,8 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
         break;
     }
     if ((ts.isArrowFunction(callee) || ts.isFunctionExpression(callee)) &&
-        isJsSourceFile(callee.getSourceFile()) &&
-        !callee.typeParameters?.length &&
+        isJsSourceFile(ts.getSourceFileOfNode(callee)) &&
+        !callee.typeParameters?.nodes.length &&
         !lowerer.preparingClassFactories.has(callee)) {
         const signature = lowerer.checker.getSignatureFromDeclaration(callee);
         let result = signature && lowerer.checker.getReturnTypeOfSignature(signature);
@@ -227,7 +276,7 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
     // Cache the module-level closure so its captures and lifted bodies are
     // exactly the ones used when the declaration executes.
     for (const signature of lowerer.checker.getConstructSignatures(type)) {
-        const declaration = lowerer.checker.signatureDeclaration(signature);
+        const declaration = signature.declaration;
         const cls = declaration && ts.isConstructorDeclaration(declaration) ? declaration.parent : null;
         if (!cls || (!ts.isClassExpression(cls) && !ts.isClassDeclaration(cls)))
             continue;
@@ -241,8 +290,8 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
             }
         }
         if (!factory ||
-            !isJsSourceFile(factory.getSourceFile()) ||
-            factory.typeParameters?.length ||
+            !isJsSourceFile(ts.getSourceFileOfNode(factory)) ||
+            factory.typeParameters?.nodes.length ||
             !ts.isVariableDeclaration(factory.parent) ||
             factory.parent.initializer !== factory ||
             !ts.isVariableDeclarationList(factory.parent.parent) ||
@@ -277,7 +326,7 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
  * or the ElementAccessExpression itself). Null when no declaration has
  * that shape (well-known-symbol members like `[Symbol.iterator]`). */
 function lateBoundKeySymOf(lowerer, p) {
-    for (const d of lowerer.checker.declarationsOf(p)) {
+    for (const d of p.declarations) {
         const access = ts.isBinaryExpression(d) && ts.isElementAccessExpression(d.left)
             ? d.left
             : ts.isElementAccessExpression(d)
@@ -311,13 +360,13 @@ function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
         return null;
     if (fnLike.type !== undefined || !fnLike.body)
         return null;
-    if (!isJsSourceFile(fnLike.getSourceFile()))
+    if (!isJsSourceFile(ts.getSourceFileOfNode(fnLike)))
         return null;
     if (fnLike.asteriskToken !== undefined)
         return null;
-    if (fnLike.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+    if (fnLike.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
         return null;
-    const stmts = fnLike.body.statements;
+    const stmts = fnLike.body.statements.nodes;
     const last = stmts[stmts.length - 1];
     if (!last || !ts.isReturnStatement(last))
         return null;
@@ -327,9 +376,9 @@ function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
             return;
         if (ts.isReturnStatement(n))
             returns.push(n);
-        n.forEachChild(visit);
+        ts.forEachChild(n, visit);
     };
-    fnLike.body.forEachChild(visit);
+    ts.forEachChild(fnLike.body, visit);
     let out = null;
     for (const r of returns) {
         let e = r.expression;
@@ -350,6 +399,16 @@ function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
     }
     return out;
 }
+/** The error classes whose values construct through error.newOptions. */
+const ERROR_CLASS_VALUES = new Set([
+    "%Error",
+    "%TypeError",
+    "%RangeError",
+    "%SyntaxError",
+    "%ReferenceError",
+    "%EvalError",
+    "%URIError",
+]);
 /** The builtin Error hierarchy
  * as eagerly-registered ClassInfos: mapType names them the moment a lib
  * Error type appears, so the infos must exist before any lowering. They
@@ -418,6 +477,17 @@ export function registerBuiltinErrorClasses(lowerer) {
                 { type: DYN, mode: "omittable" },
                 { type: DYN, mode: "omittable" },
             ],
+            // The ECMAScript error constructors take (message?, options?);
+            // DOMException, AggregateError, AssertionError and SuppressedError
+            // have their own construction and are not values.
+            ...(ERROR_CLASS_VALUES.has(irName)
+                ? {
+                    valueCtorParams: [
+                        { type: DYN, mode: "omittable" },
+                        { type: DYN, mode: "omittable" },
+                    ],
+                }
+                : {}),
             base,
             subclasses: [],
             throwingSetters: [],
@@ -450,6 +520,7 @@ export function registerBuiltinEmitterClass(lowerer) {
         // `new EventEmitter()` — zero-argument (the options bag fences at
         // construction sites; the checker may admit it via @types/node).
         ctorParams: [],
+        valueCtorParams: [],
         base: null,
         subclasses: [],
         throwingSetters: [],
@@ -457,6 +528,22 @@ export function registerBuiltinEmitterClass(lowerer) {
     };
     lowerer.classes.set(RUNTIME_EMITTER_CLASS, info);
 }
+/** `class Bus extends require("events") {}` in a CommonJS module: the
+ * events module is the EventEmitter class itself, so the base is the
+ * runtime emitter, exactly as through a `require("events")` binding. */
+export function builtinRequireBaseOf(lowerer, node) {
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (!ts.isCallExpression(expr) || !isJsSourceFile(expr.getSourceFile()))
+        return null;
+    const spec = requireSpecOf(expr);
+    if (spec === null || canonicalBuiltinModule(spec) !== "events")
+        return null;
+    if (!isCjsRequireGlobal(lowerer, expr.expression))
+        return null;
+    return lowerer.classes.get(RUNTIME_EMITTER_CLASS) ?? null;
+}
 /** The runtime-provided node:stream classes as eagerly-registered
  * ClassInfos (the emitter story): mapType names `%Readable` et al the
  * moment a stream type appears, so the infos must exist before any
@@ -480,6 +567,9 @@ export function registerBuiltinStreamClasses(lowerer) {
             // `new Readable(opts?)` — the options bag is parsed structurally
             // by the stream spoke (lowerNew never completes against this).
             ctorParams: [],
+            // Construction through a class value builds the stream without
+            // options (lowerNew reports options passed through a value).
+            valueCtorParams: [],
             base,
             subclasses: [],
             throwingSetters: [],
@@ -496,10 +586,14 @@ export function registerBuiltinStreamClasses(lowerer) {
  * "stream" ambient module, EXCLUDING @types/node's (whose stream.Readable
  * also types child stdio — under @types/node the childStream mapping
  * keeps priority and the static stream classes stand down; the shipped
- * fallback declarations are the supported surface). */
+ * fallback declarations are the supported surface). A const binding of
+ * one (`const R = Readable`) names the same class (builtinClassAliasOf). */
 export function builtinStreamInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
+    const alias = builtinClassAliasOf(lowerer, symbol);
+    if (alias !== null)
+        return alias.kind === "stream" ? alias.info : null;
     if (!lowerer.isStdlibSymbol(symbol)) {
         // A const ALIAS of a namespace member (`const Writable =
         // stream.Writable` — the two-step spelling; the one-step
@@ -507,10 +601,15 @@ export function builtinStreamInfoOf(lowerer, symbol) {
         // member to the stdlib class symbol. The declaration itself is
         // alias plumbing (streamClassAliasDecl — both declaration walks
         // skip it).
-        const decl = lowerer.checker.valueDeclarationOf(symbol);
+        // A `var`/`let` binding of the inline require member
+        // (`var Transform = require("stream").Transform`) is the same alias
+        // plumbing as builtinMemberRequireDecl's: its declaration owns no
+        // storage either way.
+        const decl = symbol.valueDeclaration;
         if (decl &&
             ts.isVariableDeclaration(decl) &&
-            (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
+            ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 ||
+                builtinMemberRequireDecl(decl.name, decl.initializer)) &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
             !decl.initializer.questionDotToken &&
@@ -524,16 +623,17 @@ export function builtinStreamInfoOf(lowerer, symbol) {
     }
     let irName = null;
     for (const [name, rec] of RUNTIME_STREAM_CLASSES) {
-        if (rec.lib === symbol.name)
+        if (rec.lib === ts.symbolName(symbol))
             irName = name;
     }
     if (!irName)
         return null;
-    const declared = lowerer.checker.declarationsOf(symbol).some((d) => {
+    // Both the bundled declarations and @types/node declare the classes
+    // inside `declare module "stream"` (@types/node nests them in the module's
+    // `internal` namespace).
+    const declared = symbol.declarations.some((d) => {
         if (!ts.isClassDeclaration(d))
             return false;
-        if (isNodeTypesPath(d.getSourceFile().fileName))
-            return false;
         let node = d.parent;
         while (node) {
             if (ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name)) {
@@ -551,10 +651,9 @@ function jsFieldInitializerType(lowerer, type, expression) {
     if (ts.isIdentifier(expression)) {
         const symbol = lowerer.checker.getSymbolAtLocation(expression);
         if (symbol &&
-            lowerer.checker
-                .declarationsOf(symbol)
-                .some((decl) => ts.isParameter(decl) &&
-                (ts.isConstructorDeclaration(decl.parent) ||
+            symbol.declarations.some((decl) => ts.isParameter(decl) &&
+                ((ts.isConstructorDeclaration(decl.parent) &&
+                    !checkedJsDocumentedParameter(lowerer, decl)) ||
                     (lowerer.typeOf(expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)))
             return DYN;
     }
@@ -563,7 +662,7 @@ function jsFieldInitializerType(lowerer, type, expression) {
     // JavaScript documentation cannot guarantee that a call or an indexed
     // read returns a present number. Numeric fields receiving those values
     // must retain undefined, so later arithmetic performs JS coercion (NaN).
-    if (type.kind === "f64" && isJsSourceFile(expression.getSourceFile())) {
+    if (type.kind === "f64" && isJsSourceFile(ts.getSourceFileOfNode(expression))) {
         const assignment = expression.parent;
         const left = ts.isBinaryExpression(assignment) ? assignment.left : null;
         const field = left &&
@@ -591,7 +690,7 @@ function jsFieldInitializerType(lowerer, type, expression) {
                     if (ts.isCallExpression(rhs) || ts.isElementAccessExpression(rhs))
                         acceptsUnchecked = true;
                 }
-                node.forEachChild(scan);
+                ts.forEachChild(node, scan);
             };
             scan(owner);
             if (acceptsUnchecked)
@@ -603,14 +702,14 @@ function jsFieldInitializerType(lowerer, type, expression) {
         node = node.expression;
     if (ts.isCallExpression(node) && type.kind === "bytes") {
         let prototypeArgument = false;
-        for (const argument of node.arguments)
+        for (const argument of node.arguments.nodes)
             ts.walkPreorder(argument, (part) => {
                 if (!ts.isPropertyAccessExpression(part) ||
                     part.expression.kind !== ts.SyntaxKind.ThisKeyword)
                     return;
                 const symbol = lowerer.checker.getSymbolAtLocation(part.name);
                 if (symbol &&
-                    lowerer.checker.declarationsOf(symbol).some((decl) => {
+                    symbol.declarations.some((decl) => {
                         const member = ts.isBinaryExpression(decl) ? decl.left : decl;
                         return (ts.isPropertyAccessExpression(member) &&
                             ts.isPropertyAccessExpression(member.expression) &&
@@ -624,7 +723,7 @@ function jsFieldInitializerType(lowerer, type, expression) {
                     owner = owner.parent;
                 if (owner && (ts.isClassDeclaration(owner) || ts.isClassExpression(owner)) && owner.name) {
                     const className = owner.name.text;
-                    for (const statement of owner.getSourceFile().statements) {
+                    for (const statement of ts.getSourceFileOfNode(owner).statements.nodes) {
                         if (!ts.isExpressionStatement(statement) ||
                             !ts.isBinaryExpression(statement.expression))
                             continue;
@@ -702,7 +801,7 @@ function inheritedJsFieldType(lowerer, decl, name, type) {
     return type;
 }
 function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
-    if (!isJsSourceFile(member.getSourceFile()) ||
+    if (!isJsSourceFile(ts.getSourceFileOfNode(member)) ||
         member.type ||
         member.asteriskToken ||
         hasExplicitJsDocReturn(member))
@@ -720,10 +819,7 @@ function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
                     ? lowerer.checker.getPropertyOfType(lowerer.typeOf(callee.expression), lowerer.foldedStringKeyOf(callee.argumentExpression) ?? "")
                     : undefined;
             if (symbol &&
-                lowerer.checker
-                    .declarationsOf(symbol)
-                    .some((declaration) => ts.isMethodDeclaration(declaration) &&
-                    lowerer.checkedVirtualJsMethods.has(declaration)))
+                symbol.declarations.some((declaration) => ts.isMethodDeclaration(declaration) && lowerer.checkedVirtualJsMethods.has(declaration)))
                 return true;
         }
         const name = ts.isPropertyAccessExpression(expression)
@@ -734,9 +830,7 @@ function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
         if (ts.isPropertyAccessExpression(expression)) {
             const symbol = lowerer.checker.getSymbolAtLocation(expression.name);
             if (symbol &&
-                lowerer.checker
-                    .declarationsOf(symbol)
-                    .some((declaration) => (ts.isGetAccessorDeclaration(declaration) ||
+                symbol.declarations.some((declaration) => (ts.isGetAccessorDeclaration(declaration) ||
                     ts.isSetAccessorDeclaration(declaration)) &&
                     lowerer.checkedVirtualJsAccessors.has(declaration)))
                 return true;
@@ -755,7 +849,7 @@ function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
             return;
         if (ts.isReturnStatement(node) && node.expression && widened(node.expression))
             result = true;
-        node.forEachChild(scan);
+        ts.forEachChild(node, scan);
     };
     if (member.body)
         scan(member.body);
@@ -768,13 +862,13 @@ function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
  * (genResultRecord's list, including scalar-backed Date values). */
 function undefArmedFieldType(lowerer, p) {
     const t = lowerer.checker.getTypeOfSymbol(p);
-    const site = lowerer.checker.declarationsOf(p)[0];
+    const site = p.declarations[0];
     let mapped = lowerer.mapTypeOf(t) ?? (site ? dynFallbackType(lowerer, site, t) : null);
     if (mapped && site)
         mapped = jsOpenObjectType(site, mapped, lowerer.shapes, lowerer.unions);
     if (!mapped || mapped.kind === "void")
         return null;
-    for (const declaration of lowerer.checker.declarationsOf(p)) {
+    for (const declaration of p.declarations) {
         const assignment = ts.isBinaryExpression(declaration) ? declaration : declaration.parent;
         if (assignment &&
             ts.isBinaryExpression(assignment) &&
@@ -801,10 +895,15 @@ function undefArmedFieldType(lowerer, p) {
  * `extends EventEmitter`, `x instanceof EventEmitter`) — any import
  * spelling (named/default/namespace member, CJS require) resolves to
  * the ambient class. Provenance-checked like the error classes: only a
- * stdlib-file declaration inside the "events" ambient module counts. */
+ * stdlib-file declaration inside the "events" ambient module counts. A
+ * const binding of it (`const E = EventEmitter`) names the same class
+ * (builtinClassAliasOf). */
 export function builtinEmitterInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
+    const alias = builtinClassAliasOf(lowerer, symbol);
+    if (alias !== null)
+        return alias.kind === "emitter" ? alias.info : null;
     if (!lowerer.isStdlibSymbol(symbol)) {
         // A const ALIAS of the emitter class member (`const EventEmitter =
         // require('node:events').EventEmitter` — commander's spelling; the
@@ -812,10 +911,11 @@ export function builtinEmitterInfoOf(lowerer, symbol) {
         // follow the member off the module namespace. The declaration
         // itself is alias plumbing (builtinMemberRequireDecl — both
         // declaration walks skip it).
-        const decl = lowerer.checker.valueDeclarationOf(symbol);
+        const decl = symbol.valueDeclaration;
         if (decl !== undefined &&
             ts.isVariableDeclaration(decl) &&
-            (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
+            ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 ||
+                builtinMemberRequireDecl(decl.name, decl.initializer)) &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
             !decl.initializer.questionDotToken &&
@@ -825,9 +925,9 @@ export function builtinEmitterInfoOf(lowerer, symbol) {
         }
         return null;
     }
-    if (symbol.name !== "EventEmitter")
+    if (ts.symbolName(symbol) !== "EventEmitter")
         return null;
-    const declared = lowerer.checker.declarationsOf(symbol).some((d) => {
+    const declared = symbol.declarations.some((d) => {
         if (!ts.isClassDeclaration(d) && !ts.isInterfaceDeclaration(d))
             return false;
         let node = d.parent;
@@ -844,12 +944,19 @@ export function builtinEmitterInfoOf(lowerer, symbol) {
 /** The builtin error ClassInfo a VALUE symbol refers to (`new Error`,
  * `extends TypeError`, `x instanceof RangeError`), or null. Provenance-
  * checked: only the standard library's declarations count — a user's own
- * `class Error` resolves through classBySymbol instead. */
+ * `class Error` resolves through classBySymbol instead. A const binding
+ * of one (`const E = TypeError`) names the same class
+ * (builtinClassAliasOf). */
 export function builtinErrorInfoOf(lowerer, symbol) {
-    if (!symbol || !lowerer.isStdlibSymbol(symbol))
+    if (!symbol)
+        return null;
+    const alias = builtinClassAliasOf(lowerer, symbol);
+    if (alias !== null)
+        return alias.kind === "error" ? alias.info : null;
+    if (!lowerer.isStdlibSymbol(symbol))
         return null;
     for (const [irName, rec] of RUNTIME_ERROR_CLASSES) {
-        if (rec.lib === symbol.name)
+        if (rec.lib === ts.symbolName(symbol))
             return lowerer.classes.get(irName) ?? null;
     }
     return null;
@@ -877,7 +984,7 @@ export const EMITTER_API_MEMBERS = new Set([
 /** The decorators of a class-like or member node (they live in
  * `modifiers` since TS 4.8). */
 export function decoratorNodesOf(n) {
-    return (n.modifiers ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
+    return (n.modifiers?.nodes ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
 }
 /** The AMBIENT name a decorator expression's evaluation throws on, or
  * null. Node erases ambient declarations (`declare let dec: any`,
@@ -936,14 +1043,14 @@ export function guaranteedDecorationThrow(lowerer, decl) {
         if (v !== "effectFree")
             return v;
     }
-    const heritage = decl.heritageClauses?.find((c) => c.token === ts.SyntaxKind.ExtendsKeyword)
-        ?.types[0];
+    const heritage = decl.heritageClauses?.nodes.find((c) => c.token === ts.SyntaxKind.ExtendsKeyword)
+        ?.types?.nodes[0];
     if (heritage) {
         const h = stripParens(heritage.expression);
         if (h.kind !== ts.SyntaxKind.NullKeyword && !ts.isIdentifier(h))
             return null;
     }
-    for (const member of decl.members) {
+    for (const member of decl.members.nodes) {
         for (const d of decoratorNodesOf(member)) {
             const v = decoratorVerdict(d);
             if (v === "opaque")
@@ -978,17 +1085,17 @@ function collectClassShapeDeferring(lowerer, decl) {
         // A forward type reference can demand this class before collection
         // reaches its earlier base declaration. Collect that dependency first;
         // a later same-file base remains subject to the runtime order boundary.
-        const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+        const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
         const reference = heritage && ts.isPropertyAccessExpression(heritage) ? heritage.name : heritage;
         const baseSymbol = reference && ts.isIdentifier(reference) ? lowerer.resolveValueSymbol(reference) : undefined;
         const baseDeclaration = baseSymbol
-            ? lowerer.checker.declarationsOf(baseSymbol).find(ts.isClassDeclaration)
+            ? baseSymbol.declarations.find(ts.isClassDeclaration)
             : undefined;
         if (baseDeclaration &&
             !lowerer.isStdlibSymbol(baseSymbol ?? undefined) &&
-            !baseDeclaration.getSourceFile().isDeclarationFile &&
-            (baseDeclaration.getSourceFile() !== decl.getSourceFile() ||
-                baseDeclaration.getStart() < decl.getStart()))
+            !ts.getSourceFileOfNode(baseDeclaration).isDeclarationFile &&
+            (ts.getSourceFileOfNode(baseDeclaration) !== ts.getSourceFileOfNode(decl) ||
+                ts.tokenStartOfNode(baseDeclaration) < ts.tokenStartOfNode(decl)))
             lowerer.collectClassShape(baseDeclaration);
         lowerer.collectClassShapeInner(decl);
     });
@@ -1003,8 +1110,8 @@ function collectClassShapeDeferring(lowerer, decl) {
     // declaration without a diagnostic would drop observable side effects (the
     // classStaticBlock13/28 miscompiles).
     const hasDeclTimeCode = (n) => ts.isClassStaticBlockDeclaration(n) ||
-        (n.modifiers ?? []).some((m) => m.kind === ts.SyntaxKind.Decorator);
-    if (symbol && (hasDeclTimeCode(decl) || decl.members.some(hasDeclTimeCode))) {
+        (n.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.Decorator);
+    if (symbol && (hasDeclTimeCode(decl) || decl.members.nodes.some(hasDeclTimeCode))) {
         lowerer.reportDeferred(symbol);
     }
     // A poisoned BASE this class EXTENDS must report EAGERLY for the same
@@ -1018,9 +1125,9 @@ function collectClassShapeDeferring(lowerer, decl) {
     // reports. Resolution runs under the collect pass's guard (this is
     // collectProgram), so the lookup neither flushes nor fences.
     {
-        const baseIdent = decl.heritageClauses
-            ?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword)
-            ?.types.map((t) => t.expression)
+        const baseIdent = decl.heritageClauses?.nodes
+            .find((h) => h.token === ts.SyntaxKind.ExtendsKeyword)
+            ?.types?.nodes.map((t) => t.expression)
             .filter(ts.isIdentifier)[0];
         const baseSym = baseIdent ? lowerer.resolveValueSymbol(baseIdent) : null;
         if (baseSym)
@@ -1029,7 +1136,7 @@ function collectClassShapeDeferring(lowerer, decl) {
 }
 function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
     if (!ts.isNewExpression(initializer) ||
-        (initializer.arguments?.length ?? 0) !== 0 ||
+        (initializer.arguments?.nodes.length ?? 0) !== 0 ||
         !ts.isIdentifier(initializer.expression))
         return null;
     const collection = initializer.expression.text;
@@ -1044,7 +1151,12 @@ function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
     const mappedArgument = (argument) => {
         const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(argument));
         const mapped = lowerer.mapTypeOf(type);
-        if (!mapped || mapped.kind === "dyn" || mapped.kind === "void" || isUnitType(mapped))
+        // Inferred JS collection fields keep functions in checked slots.
+        if (!mapped ||
+            mapped.kind === "dyn" ||
+            mapped.kind === "void" ||
+            mapped.kind === "func" ||
+            isUnitType(mapped))
             return null;
         return mapped;
     };
@@ -1061,9 +1173,9 @@ function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
         }
         if (collection === "Map" &&
             node.expression.name.text === "set" &&
-            node.arguments.length === 2) {
-            const key = mappedArgument(node.arguments[0]);
-            const value = mappedArgument(node.arguments[1]);
+            node.arguments.nodes.length === 2) {
+            const key = mappedArgument(node.arguments.nodes[0]);
+            const value = mappedArgument(node.arguments.nodes[1]);
             if (key !== null &&
                 value !== null &&
                 isSupportedMapKey(key, key.kind === "union" ? lowerer.unions.get(key.unionId)?.arms : undefined) &&
@@ -1076,15 +1188,15 @@ function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
             (node.expression.name.text === "add" ||
                 node.expression.name.text === "has" ||
                 node.expression.name.text === "delete") &&
-            node.arguments.length === 1) {
-            const element = mappedArgument(node.arguments[0]);
+            node.arguments.nodes.length === 1) {
+            const element = mappedArgument(node.arguments.nodes[0]);
             if (element !== null &&
                 isSupportedSetElem(element, element.kind === "union" ? lowerer.unions.get(element.unionId)?.arms : undefined))
                 setElements.push(element);
         }
         return undefined;
     };
-    for (const member of decl.members) {
+    for (const member of decl.members.nodes) {
         const body = ts.isConstructorDeclaration(member) || ts.isMethodDeclaration(member) || ts.isAccessor(member)
             ? member.body
             : undefined;
@@ -1136,13 +1248,13 @@ mixin) {
         const classDecoratorNodes = [];
         {
             classDecoratorNodes.push(...decoratorNodesOf(decl));
-            const decoratedMembers = decl.members.filter((m) => decoratorNodesOf(m).length > 0);
+            const decoratedMembers = decl.members.nodes.filter((m) => decoratorNodesOf(m).length > 0);
             if (classDecoratorNodes.length > 0 || decoratedMembers.length > 0) {
                 // Node itself cannot execute decorator syntax in a JavaScript
                 // source (V8 has not shipped the proposal; the type-stripping
                 // loaders leave `@dec` in place) — there is no runtime behavior
                 // to be exact against.
-                if (isJsSourceFile(decl.getSourceFile())) {
+                if (isJsSourceFile(ts.getSourceFileOfNode(decl))) {
                     lowerer.unsupported("SC1090", (classDecoratorNodes[0] ?? decoratorNodesOf(decoratedMembers[0])[0]), "decorators in JavaScript sources (V8 has not shipped decorators — Node cannot execute this file)");
                 }
                 // The guaranteed-throw SHELL: declarations only (expressions
@@ -1197,7 +1309,7 @@ mixin) {
                         : ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)
                             ? "accessor decorators"
                             : ts.isPropertyDeclaration(member)
-                                ? member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)
+                                ? member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)
                                     ? "auto-accessor decorators"
                                     : "field decorators"
                                 : "member decorators";
@@ -1259,9 +1371,9 @@ mixin) {
                 return true;
             }
             const signatures = lowerer.checker.getCallSignatures(lowerer.typeOf(expression));
-            const source = signatures.length === 1 ? lowerer.checker.signatureDeclaration(signatures[0]) : undefined;
+            const source = signatures.length === 1 ? signatures[0].declaration : undefined;
             if (!source ||
-                !isJsSourceFile(source.getSourceFile()) ||
+                !isJsSourceFile(ts.getSourceFileOfNode(source)) ||
                 !(ts.isFunctionDeclaration(source) || ts.isFunctionExpression(source)))
                 return false;
             callableBase = {
@@ -1278,14 +1390,14 @@ mixin) {
             if (!base || base.generic)
                 lowerer.unsupported("SC1090", ownGenericBase, "a generic base whose type arguments have no concrete layout");
         }
-        for (const clause of inst || mixin || computedBase ? [] : (decl.heritageClauses ?? [])) {
+        for (const clause of inst || mixin || computedBase ? [] : (decl.heritageClauses?.nodes ?? [])) {
             // `implements` is pure type-world: tsc checked the conformance and
             // the clause erases — nothing about the runtime class changes.
             // (Assigning an instance INTO an interface-typed slot is a separate
             // question, owned by the shape-coercion fences at those sites.)
             if (clause.token === ts.SyntaxKind.ImplementsKeyword)
                 continue;
-            const t = clause.types[0];
+            const t = clause.types.nodes[0];
             if (familyMode && t) {
                 const reference = ts.isPropertyAccessExpression(t.expression)
                     ? t.expression.name
@@ -1316,7 +1428,7 @@ mixin) {
                 if (globalError &&
                     globalError.def.name !== "%DOMException" &&
                     globalError.def.name !== "%AggregateError") {
-                    if (t.typeArguments)
+                    if (t.typeArguments?.nodes)
                         lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = globalError;
                     continue;
@@ -1324,7 +1436,7 @@ mixin) {
                 const emitterBase = lowerer.builtinEmitterInfoOf(resolved);
                 const streamBaseNs = builtinStreamInfoOf(lowerer, resolved);
                 if (emitterBase || streamBaseNs) {
-                    if (t.typeArguments)
+                    if (t.typeArguments?.nodes)
                         lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = (emitterBase ?? streamBaseNs);
                     continue;
@@ -1345,7 +1457,7 @@ mixin) {
                             continue;
                         lowerer.unsupported("SC1090", t, `extending the namespace member '${t.expression.name.text}' (no class lowering)`);
                     }
-                    if (t.typeArguments)
+                    if (t.typeArguments?.nodes)
                         lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = nsBase;
                     continue;
@@ -1364,13 +1476,13 @@ mixin) {
                 if (!t.expression.questionDotToken) {
                     const propBase = propertyAssignedClassInfoOf(lowerer, memberSym);
                     if (propBase) {
-                        if (t.typeArguments)
+                        if (t.typeArguments?.nodes)
                             lowerer.unsupported("SC1090", t, "extending generic classes");
                         const baseDecl = propBase.decl;
                         if (baseDecl != null &&
-                            baseDecl.getSourceFile() === decl.getSourceFile() &&
-                            baseDecl.getStart() > decl.getStart()) {
-                            lowerer.unsupported("SC1090", t, `extending '${t.expression.getText()}' above the statement that assigns it (the property is still undefined when this class evaluates — Node throws here; assign the base first)`);
+                            ts.getSourceFileOfNode(baseDecl) === ts.getSourceFileOfNode(decl) &&
+                            ts.tokenStartOfNode(baseDecl) > ts.tokenStartOfNode(decl)) {
+                            lowerer.unsupported("SC1090", t, `extending '${ts.getTextOfNode(t.expression)}' above the statement that assigns it (the property is still undefined when this class evaluates — Node throws here; assign the base first)`);
                         }
                         base = propBase;
                         continue;
@@ -1379,11 +1491,9 @@ mixin) {
                     // fence (the generic computed-expression one below would hide
                     // what actually blocks it).
                     const rebinds = memberSym !== undefined &&
-                        lowerer.checker
-                            .declarationsOf(memberSym)
-                            .filter((d) => ts.isBinaryExpression(d) && d.operatorToken.kind === ts.SyntaxKind.EqualsToken).length > 1;
+                        memberSym.declarations.filter((d) => ts.isBinaryExpression(d) && d.operatorToken.kind === ts.SyntaxKind.EqualsToken).length > 1;
                     if (rebinds) {
-                        lowerer.unsupported("SC1090", t, `extending the reassigned property '${t.expression.getText()}' (the runtime base is whichever assignment ran last — bind the class exactly once)`);
+                        lowerer.unsupported("SC1090", t, `extending the reassigned property '${ts.getTextOfNode(t.expression)}' (the runtime base is whichever assignment ran last — bind the class exactly once)`);
                     }
                 }
             }
@@ -1392,7 +1502,7 @@ mixin) {
             // so its statics queue ahead of the derived class's — the
             // recursion order delivers exactly that).
             if (t && ts.isClassExpression(t.expression)) {
-                if (t.typeArguments)
+                if (t.typeArguments?.nodes)
                     lowerer.unsupported("SC1090", t, "extending generic classes");
                 const baseExpr = lowerer.lowerClassExpressionInfo(t.expression);
                 base = baseExpr;
@@ -1404,7 +1514,12 @@ mixin) {
             // through the monomorphized chain (lower-mixins.ts). A call whose
             // callee is NOT a mixin function keeps the computed-expression
             // fence below.
-            if (t && ts.isCallExpression(t.expression) && !t.typeArguments) {
+            if (t && ts.isCallExpression(t.expression) && !t.typeArguments?.nodes) {
+                const requiredBase = builtinRequireBaseOf(lowerer, t.expression);
+                if (requiredBase) {
+                    base = requiredBase;
+                    continue;
+                }
                 const mixinBase = lowerer.mixinCallClassInfoOf(t.expression);
                 if (mixinBase) {
                     base = mixinBase;
@@ -1492,7 +1607,7 @@ mixin) {
                 base = instBase;
                 continue;
             }
-            if (t.typeArguments)
+            if (t.typeArguments?.nodes)
                 lowerer.unsupported("SC1090", t, "extending generic classes");
             base = named;
             if (!base) {
@@ -1502,7 +1617,7 @@ mixin) {
             }
         }
         if (base?.localClass && !functionLocalClass(decl) && !computedBase && !factoryBaseExpression) {
-            const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0];
+            const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0];
             if (heritage)
                 factoryBaseExpression = heritage.expression;
             else
@@ -1510,9 +1625,7 @@ mixin) {
         }
         if (lowerer.collectingExprClasses.has(decl)) {
             for (let parent = base; parent; parent = parent.base) {
-                if (parent.builtinEmitter ||
-                    parent.builtinStream !== undefined ||
-                    parent.builtinEventTarget !== undefined) {
+                if (parent.builtinEventTarget !== undefined) {
                     lowerer.unsupported("SC1090", decl, "classes extending builtin bases as values (the inherited runtime constructor has no class-value adapter)");
                 }
             }
@@ -1535,6 +1648,7 @@ mixin) {
         const fieldOrder = [];
         const methods = new Map();
         const methodEntryFences = new Map();
+        const returnAdapters = new Map();
         // Own accessor declarations ("get:x"/"set:x" → node), for the
         // partial-override analysis below (diagnostics need the node).
         const accessorNodes = new Map();
@@ -1563,12 +1677,12 @@ mixin) {
         const runtimePrototypeMembers = [];
         // Public JS accessors need live constructor descriptors, including
         // receiver-sensitive getters and setters inherited by subclasses.
-        const checkedStatics = isJsSourceFile(decl.getSourceFile()) &&
+        const checkedStatics = isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             ((base && hasRuntimeStatics(base)) ||
-                decl.members.some((member) => ts.isAccessor(member) &&
+                decl.members.nodes.some((member) => ts.isAccessor(member) &&
                     !ts.isPrivateIdentifier(member.name) &&
-                    member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
-            !decl.members.some((member) => member.name &&
+                    member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
+            !decl.members.nodes.some((member) => member.name &&
                 ts.isPrivateIdentifier(member.name) &&
                 ts
                     .getModifiers(member)
@@ -1601,13 +1715,13 @@ mixin) {
                 lowerer.unsupported("SC1071", member);
             const mName = member.name.text;
             const typeParams = [];
-            for (const tp of fnNode.typeParameters) {
+            for (const tp of fnNode.typeParameters.nodes) {
                 const sym = lowerer.checker.getSymbolAtLocation(tp.name);
                 if (!sym)
                     lowerer.unsupported("SC1090", member, "this method form");
                 typeParams.push(sym);
             }
-            for (const param of fnNode.parameters) {
+            for (const param of fnNode.parameters.nodes) {
                 if (!ts.isIdentifier(param.name) &&
                     !ts.isObjectBindingPattern(param.name) &&
                     !ts.isArrayBindingPattern(param.name)) {
@@ -1622,9 +1736,9 @@ mixin) {
                 instances: new Map(),
             });
         };
-        for (const member of decl.members) {
+        for (const member of decl.members.nodes) {
             if ((functionLocalClass(decl) || checkedStatics) &&
-                isJsSourceFile(decl.getSourceFile()) &&
+                isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                 (ts.isClassStaticBlockDeclaration(member) ||
                     ts
                         .getModifiers(member)
@@ -1633,7 +1747,7 @@ mixin) {
                 continue;
             }
             if (functionLocalClass(decl) &&
-                isJsSourceFile(decl.getSourceFile()) &&
+                isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                 (ts.isMethodDeclaration(member) || ts.isAccessor(member)) &&
                 member.body &&
                 !ts.isPrivateIdentifier(member.name)) {
@@ -1698,11 +1812,11 @@ mixin) {
                     if (type.kind === "void")
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
                     if (type.kind === "dyn" &&
-                        !isJsSourceFile(member.getSourceFile()) &&
+                        !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                         !lowerer.classFieldStoresDyn(lowerer.typeOf(member.name)) &&
                         (member.type !== undefined ||
                             (lowerer.typeOf(member.name).flags & ts.TypeFlags.Any) === 0)) {
-                        lowerer.unsupported("SC1090", member.name, "'unknown'-typed static fields");
+                        lowerer.unsupported("SC1090", member.name, `${dynFieldTypeSpelling(lowerer, member.name)}-typed static fields`);
                     }
                     staticFields.push({
                         name: member.name.text,
@@ -1724,7 +1838,7 @@ mixin) {
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
                     }
                     staticMethods.set(member.name.text, { params: shapes, ret: ft.ret, member });
-                    if (implicitMonoFile(decl.getSourceFile()) &&
+                    if (implicitMonoFile(ts.getSourceFileOfNode(decl)) &&
                         !functionLocalClass(decl) &&
                         inst === undefined &&
                         decl.typeParameters === undefined) {
@@ -1769,9 +1883,21 @@ mixin) {
             const memberName = member.name;
             if (errorRooted && memberName && classMemberNameOf(lowerer, memberName) === "cause") {
                 if (ts.isPropertyDeclaration(member) &&
-                    !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
-                    if (!isJsSourceFile(member.getSourceFile()))
-                        lowerer.unsupported("SC1090", memberName, "redeclaring Error.cause (pass the cause in the Error constructor options)");
+                    !member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
+                    // A TypeScript redeclaration is the JavaScript field: Node
+                    // defines the Error's own `cause` (undefined without an
+                    // initializer) after super() returns. `declare` and `abstract`
+                    // declarations are erased and define nothing. Every `.cause`
+                    // read of an Error-rooted class is the checked-dynamic property
+                    // (fieldTarget's errorCause container), so only types that read
+                    // back unchanged from it are accepted.
+                    if (!isJsSourceFile(ts.getSourceFileOfNode(member))) {
+                        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.DeclareKeyword ||
+                            m.kind === ts.SyntaxKind.AbstractKeyword))
+                            continue;
+                        if (!lowerer.classFieldStoresDyn(lowerer.typeOf(member.name)))
+                            lowerer.unsupported("SC1090", memberName, "redeclaring Error.cause with a type other than 'unknown' or 'object' (declare it 'cause?: unknown' and narrow at the read)");
+                    }
                     fieldOrder.push({
                         name: "cause",
                         type: DYN,
@@ -1837,11 +1963,11 @@ mixin) {
                     !inst &&
                     !mixin &&
                     ts.isMethodDeclaration(member) &&
-                    !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
+                    !member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
                     const reason = emitOverrideShapeReason(lowerer, member);
                     if (reason === null) {
-                        const eventSym = lowerer.checker.getSymbolAtLocation(member.parameters[0].name);
-                        const restSym = lowerer.checker.getSymbolAtLocation(member.parameters[1].name);
+                        const eventSym = lowerer.checker.getSymbolAtLocation(member.parameters.nodes[0].name);
+                        const restSym = lowerer.checker.getSymbolAtLocation(member.parameters.nodes[1].name);
                         if (eventSym && restSym) {
                             emitOverride = { decl: member, eventSym, restSym };
                             continue;
@@ -1889,6 +2015,21 @@ mixin) {
                             lowerer.unsupported("SC1090", memberName, `declaring '${name}' on a ${streamBase.def.name.slice(1)} subclass (its constructor consumes ${accepted.map((a) => `'${UNDERSCORE_METHODS.get(a)}'`).join("/")})`);
                         }
                     }
+                    // A completion callback declared with the broad `Function` type
+                    // (`cb: Function`) takes the checked-dynamic callable the runtime
+                    // passes implicitly typed callbacks; calls through it are
+                    // dynamic calls of that callable.
+                    const callbackIndex = STREAM_COMPLETION_CALLBACK_INDEX.get(name);
+                    const callbackParam = ts.isMethodDeclaration(member) && callbackIndex !== undefined
+                        ? member.parameters.nodes[callbackIndex]
+                        : undefined;
+                    if (callbackParam !== undefined &&
+                        ts.isIdentifier(callbackParam.name) &&
+                        !callbackParam.dotDotDotToken &&
+                        !callbackParam.questionToken &&
+                        !callbackParam.initializer &&
+                        lowerer.checker.typeToString(lowerer.typeOf(callbackParam.name)) === "Function")
+                        lowerer.checkedCallbackParams.add(callbackParam);
                 }
             }
             if (ts.isPropertyDeclaration(member)) {
@@ -1921,18 +2062,27 @@ mixin) {
                             ? String(Number(member.name.text))
                             : member.name.text;
                     const fieldName = symbolKey?.fieldName ?? stringKey;
+                    // A TypeScript field without an initializer takes its declared
+                    // type and the identifier fields' definite-assignment rule (an
+                    // unconditional `this[key] = ...` at the constructor's top
+                    // level), checked with the unguarded fields below.
+                    const declaredOnly = !member.initializer && !isJsSourceFile(ts.getSourceFileOfNode(member)) && !!member.type;
                     if (fieldName === null ||
-                        (!member.initializer && !isJsSourceFile(member.getSourceFile()))) {
+                        (!member.initializer &&
+                            !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                            !declaredOnly)) {
                         lowerer.unsupported("SC1090", member, "computed class fields without an initializer and a stable string, number, or module-level literal Symbol()/Symbol.for() key");
                     }
                     const declared = lowerer.typeOf(member);
                     const inferred = member.type || !member.initializer
                         ? declared
                         : lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(member.initializer));
-                    const mapped = member.initializer
+                    const mapped = member.initializer || declaredOnly
                         ? (lowerer.mapTypeOf(inferred) ?? dynFallbackType(lowerer, member, inferred))
                         : DYN;
-                    let type = mapped?.kind === "record" && isJsSourceFile(member.getSourceFile()) && !member.type
+                    let type = mapped?.kind === "record" &&
+                        isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                        !member.type
                         ? DYN
                         : mapped
                             ? jsOpenObjectType(member, mapped, lowerer.shapes, lowerer.unions)
@@ -1940,17 +2090,29 @@ mixin) {
                     if (!type ||
                         type.kind === "void" ||
                         (type.kind === "dyn" &&
-                            !isJsSourceFile(member.getSourceFile()) &&
-                            !lowerer.classImplementedProtocol(inferred)))
+                            !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                            !lowerer.classFieldStoresDyn(inferred)))
                         lowerer.badType(member, inferred);
-                    if (isJsSourceFile(member.getSourceFile())) {
+                    if (isJsSourceFile(ts.getSourceFileOfNode(member))) {
                         type = inheritedJsFieldType(lowerer, decl, fieldName, type);
                         if (base?.fields.get(fieldName)?.kind === "dyn")
                             type = DYN;
                         if (base && !fields.has(fieldName) && lowerer.dynConvertible(type))
                             type = DYN;
                     }
-                    const undefinedInitializer = !member.initializer ? locOf(member) : undefined;
+                    const undefinedInitializer = !member.initializer && (!declaredOnly || type.kind === "dyn")
+                        ? locOf(member)
+                        : undefined;
+                    if (declaredOnly &&
+                        type.kind !== "dyn" &&
+                        !(type.kind === "union" &&
+                            lowerer.unions.get(type.unionId)?.arms.some((a) => a.kind === "undefinedT"))) {
+                        unguardedFields.push({
+                            node: member.name,
+                            name: fieldName,
+                            why: `initializer-less computed fields not assigned at the constructor's top level (nothing guarantees '${symbolKey ? symbolFieldDisplayName(fieldName) : fieldName}' is assigned before a read — assign it unconditionally at the top of the constructor, give it an initializer, or include undefined in its type)`,
+                        });
+                    }
                     const previous = fields.get(fieldName);
                     if (previous) {
                         if (symbolKey && !symbolFields.has(symbolKey.identity)) {
@@ -2026,9 +2188,9 @@ mixin) {
                 // as undefined on construction, verified), and reads/writes ride
                 // the ordinary undefined-armed union machinery.
                 let type = lowerer.irTypeOf(member.name);
-                if (isJsSourceFile(member.getSourceFile()) && !member.initializer) {
-                    const constructor = decl.members.find((part) => ts.isConstructorDeclaration(part) && !!part.body);
-                    for (const statement of constructor?.body?.statements ?? []) {
+                if (isJsSourceFile(ts.getSourceFileOfNode(member)) && !member.initializer) {
+                    const constructor = decl.members.nodes.find((part) => ts.isConstructorDeclaration(part) && !!part.body);
+                    for (const statement of constructor?.body?.statements?.nodes ?? []) {
                         if (!ts.isExpressionStatement(statement) ||
                             !ts.isBinaryExpression(statement.expression) ||
                             statement.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
@@ -2046,18 +2208,20 @@ mixin) {
                 }
                 // Unannotated JavaScript callback slots retain the original
                 // callable and its receiver instead of adapting its signature.
-                if (isJsSourceFile(member.getSourceFile()) &&
+                if (isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                     !member.type &&
-                    !/@type\b/.test(member.getSourceFile().text.slice(member.pos, member.getStart())) &&
+                    !/@type\b/.test(ts.getSourceFileOfNode(member).text.slice(member.pos, ts.tokenStartOfNode(member))) &&
                     (type.kind === "func" || type.kind === "record") &&
                     lowerer.dynConvertible(type))
                     type = DYN;
                 // JS permits reads before a constructor's first assignment even
                 // when its inferred field type omits undefined.
-                if (isJsSourceFile(member.getSourceFile()) && !member.initializer && type.kind !== "dyn") {
+                if (isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                    !member.initializer &&
+                    type.kind !== "dyn") {
                     type = lowerer.withUndefinedArmOf(type) ?? DYN;
                 }
-                if (isJsSourceFile(member.getSourceFile())) {
+                if (isJsSourceFile(ts.getSourceFileOfNode(member))) {
                     type = inheritedJsFieldType(lowerer, decl, member.name.text, type);
                     if (base?.fields.get(member.name.text)?.kind === "dyn")
                         type = DYN;
@@ -2070,9 +2234,9 @@ mixin) {
                 // them in the constructor. Use the same native checked-dynamic
                 // storage as implicit constructor-assigned JS fields.
                 if (type.kind === "dyn" &&
-                    !isJsSourceFile(member.getSourceFile()) &&
+                    !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                     !lowerer.classFieldStoresDyn(lowerer.typeOf(member.name))) {
-                    lowerer.unsupported("SC1090", member.name, "'unknown'-typed class fields");
+                    lowerer.unsupported("SC1090", member.name, `${dynFieldTypeSpelling(lowerer, member.name)}-typed class fields`);
                 }
                 const undefinedInitializer = type.kind === "dyn" && !member.initializer ? locOf(member) : undefined;
                 if (fields.has(member.name.text)) {
@@ -2171,8 +2335,8 @@ mixin) {
                 // FIRST (before every declared field, as undefined), and the
                 // assignments run after super() and the field initializers, in
                 // parameter order (see paramPropInitStmts).
-                for (const p of member.parameters) {
-                    const isParamProp = p.modifiers?.some((m) => m.kind === ts.SyntaxKind.PublicKeyword ||
+                for (const p of member.parameters.nodes) {
+                    const isParamProp = p.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.PublicKeyword ||
                         m.kind === ts.SyntaxKind.PrivateKeyword ||
                         m.kind === ts.SyntaxKind.ProtectedKeyword ||
                         m.kind === ts.SyntaxKind.ReadonlyKeyword ||
@@ -2180,7 +2344,7 @@ mixin) {
                     if (!isParamProp) {
                         // Non-keyword modifiers (parameter decorators) are rejected
                         // by tsc under standard decorators; defensive.
-                        if (p.modifiers?.length)
+                        if (p.modifiers?.nodes.length)
                             lowerer.unsupported("SC1090", p, "this parameter form");
                         continue;
                     }
@@ -2191,7 +2355,7 @@ mixin) {
                     }
                     const name = p.name.text;
                     if (errorRooted && name === "cause") {
-                        lowerer.unsupported("SC1090", p.name, "redeclaring Error.cause (pass the cause in the Error constructor options)");
+                        lowerer.unsupported("SC1090", p.name, "redeclaring Error.cause as a parameter property (declare 'cause?: unknown' and assign it in the constructor)");
                     }
                     const shape = lowerer.paramShape(p);
                     const type = shape.bodyType ?? shape.type;
@@ -2199,7 +2363,7 @@ mixin) {
                         lowerer.badType(p.name, lowerer.typeOf(p.name));
                     // The class-field dyn rule verbatim (KEEP NARROW).
                     if (type.kind === "dyn" && !lowerer.classFieldStoresDyn(lowerer.typeOf(p))) {
-                        lowerer.unsupported("SC1090", p.name, "'unknown'-typed class fields");
+                        lowerer.unsupported("SC1090", p.name, `${dynFieldTypeSpelling(lowerer, p)}-typed class fields`);
                     }
                     // `override x` (and any same-named inherited member) would
                     // redeclare a base slot — the declared-field rule verbatim.
@@ -2257,7 +2421,14 @@ mixin) {
                             !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ret, overridden.sig.ret, className, base)))) {
                         lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
-                    methods.set(mName, { params: shapes, ret, abstract: true });
+                    const unionReturn = overridden?.sig.ret.kind === "union" && !typeEquals(ret, overridden.sig.ret);
+                    if (unionReturn)
+                        lowerer.unionReturnOverrides.add(member);
+                    methods.set(mName, {
+                        params: shapes,
+                        ret: unionReturn ? overridden.sig.ret : ret,
+                        abstract: true,
+                    });
                     continue;
                 }
                 // A body-less method is an OVERLOAD SIGNATURE (abstract methods
@@ -2292,7 +2463,7 @@ mixin) {
                 // dispatch worlds could meet: an inherited declaration of the
                 // name (the override stays on the vtable), a shadowed field, or
                 // a generic-class instantiation's member.
-                if (implicitMonoFile(decl.getSourceFile()) &&
+                if (implicitMonoFile(ts.getSourceFileOfNode(decl)) &&
                     !functionLocalClass(decl) &&
                     ts.isIdentifier(member.name) &&
                     !lowerer.virtualJsMethods.has(member) &&
@@ -2332,12 +2503,12 @@ mixin) {
                 }
                 // JS inference may retain only a symbol sentinel while a method
                 // also returns values from an untyped mutable field or local.
-                if (isJsSourceFile(member.getSourceFile()) &&
+                if (isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                     !member.type &&
                     !hasExplicitJsDocReturn(member) &&
                     ft.ret.kind === "symbol")
                     ft.ret = DYN;
-                if (isJsSourceFile(member.getSourceFile()) &&
+                if (isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                     lowerer.prototypeMethodAccesses.has(mName) &&
                     !lowerer.findMethodOn(base, mName)?.declarer.def.runtime &&
                     shapes.every((p) => p.mode === "required" || p.mode === "omittable")) {
@@ -2386,7 +2557,7 @@ mixin) {
                 // against the STATIC receiver's shape, so `m(x?: number)` and
                 // `m(x: number | undefined)` interchange soundly in overrides.
                 const overridden = lowerer.findMethodOn(base, mName);
-                if (overridden && isJsSourceFile(member.getSourceFile())) {
+                if (overridden && isJsSourceFile(ts.getSourceFileOfNode(member))) {
                     // An unannotated JS override can return a checked value into
                     // the inherited native ABI, just as its untyped parameters do.
                     // Body lowering inserts the conversion at each return.
@@ -2408,7 +2579,7 @@ mixin) {
                     // Defaults stay local to each declaration, so only inherited
                     // required/optional slots participate in this refinement.
                     for (let i = 0; i < shapes.length; i++) {
-                        const parameter = member.parameters[i];
+                        const parameter = member.parameters.nodes[i];
                         const inherited = overridden.sig.params[i];
                         if (parameter &&
                             inherited &&
@@ -2427,7 +2598,7 @@ mixin) {
                 // calls fill them with undefined. Typed tails and rest/arguments
                 // readers keep the exact-signature fence.
                 if (overridden &&
-                    isJsSourceFile(member.getSourceFile()) &&
+                    isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                     shapes.length < overridden.sig.params.length &&
                     !bodyReadsArguments(member) &&
                     shapes.every((p, i) => (p.mode === "required" || p.mode === "omittable") &&
@@ -2439,28 +2610,116 @@ mixin) {
                         .slice(shapes.length)
                         .map((p) => ({ type: p.type, mode: "omittable" })));
                 }
+                // A TypeScript override of a JavaScript method (`class T extends
+                // Agent` over an npm-static package) keeps the base's checked-value
+                // ABI: each untyped base slot stays dyn, and the override's typed
+                // parameter narrows from it at entry with a checked conversion. An
+                // untyped base return takes the override's value boxed. Calls on
+                // a statically typed receiver see the same ABI.
+                if (overridden &&
+                    !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                    overridden.declarer.decl !== null &&
+                    isJsSourceFile(ts.getSourceFileOfNode(overridden.declarer.decl)) &&
+                    member.asteriskToken === undefined &&
+                    !overridden.sig.async &&
+                    !overridden.sig.gen &&
+                    shapes.length <= overridden.sig.params.length &&
+                    shapes.every((p, i) => {
+                        const inherited = overridden.sig.params[i];
+                        return ((p.mode === "required" || p.mode === "omittable") &&
+                            p.bodyType === undefined &&
+                            (inherited.mode === "required" || inherited.mode === "omittable") &&
+                            (typeEquals(p.type, inherited.type) ||
+                                (inherited.type.kind === "dyn" && lowerer.dynConvertible(p.type))));
+                    }) &&
+                    overridden.sig.params
+                        .slice(shapes.length)
+                        .every((p) => p.type.kind === "dyn" && (p.mode === "required" || p.mode === "omittable"))) {
+                    for (let i = 0; i < shapes.length; i++) {
+                        const own = shapes[i];
+                        if (overridden.sig.params[i].type.kind === "dyn" && own.type.kind !== "dyn")
+                            shapes[i] = { type: DYN, mode: own.mode, entryNarrow: own.type };
+                    }
+                    shapes.push(...overridden.sig.params
+                        .slice(shapes.length)
+                        .map((p) => ({ type: p.type, mode: "omittable" })));
+                    if (overridden.sig.ret.kind === "dyn" &&
+                        ft.ret.kind !== "dyn" &&
+                        ft.ret.kind !== "void" &&
+                        lowerer.dynConvertible(ft.ret))
+                        ft.ret = DYN;
+                    ft.params = shapes.map((shape) => shape.type);
+                }
                 if (overridden &&
                     member.asteriskToken === undefined &&
                     (overridden.sig.params.length !== shapes.length ||
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
                         !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ft.ret, overridden.sig.ret, className, base)))) {
-                    const fencedJsOverride = isJsSourceFile(member.getSourceFile()) &&
+                    const fencedJsOverride = isJsSourceFile(ts.getSourceFileOfNode(member)) &&
                         overridden.declarer.decl !== null &&
-                        isJsSourceFile(overridden.declarer.decl.getSourceFile()) &&
+                        isJsSourceFile(ts.getSourceFileOfNode(overridden.declarer.decl)) &&
                         overridden.sig.gen === undefined;
-                    if (fencedJsOverride) {
+                    // A TypeScript override that only changes the result, into a
+                    // type that converts into the inherited one (`Promise<void>` over
+                    // an `any` base, `string | undefined` over `string`): the slot
+                    // keeps the inherited ABI and converts the body's result at the
+                    // boundary (lowerClassMethodMemberInner).
+                    const ownAsync = member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+                    if (!fencedJsOverride &&
+                        !functionLocalClass(decl) &&
+                        overridden.sig.gen === undefined &&
+                        // An async base's slot answers its promise: a Promise type, or
+                        // the checked-dynamic value of an untyped async method.
+                        (overridden.sig.async !== true ||
+                            overridden.sig.ret.kind === "promise" ||
+                            overridden.sig.ret.kind === "dyn") &&
+                        !overridden.sig.abstract &&
+                        overridden.sig.params.length === shapes.length &&
+                        overridden.sig.params.every((p, i) => p.mode === shapes[i].mode &&
+                            (p.mode === "required" || p.mode === "omittable") &&
+                            // Each inherited argument converts into the override's
+                            // parameter: equal, a checked extraction from an `any`
+                            // slot, or a widening (a contravariant parameter).
+                            (typeEquals(p.type, shapes[i].type) ||
+                                (p.type.kind === "dyn" &&
+                                    canDynCheckTo(shapes[i].type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) ||
+                                lowerer.coercibleValue(p.type, shapes[i].type))) &&
+                        (ownAsync ? ft.ret.kind === "promise" : true) &&
+                        (typeEquals(ft.ret, overridden.sig.ret) ||
+                            (overridden.sig.ret.kind === "dyn"
+                                ? ft.ret.kind !== "void" && lowerer.dynConvertible(ft.ret)
+                                : lowerer.coercibleValue(ft.ret, overridden.sig.ret) ||
+                                    // A promise whose payload widens into the inherited one
+                                    // (`Promise<void>` over an untyped async `Promise<any>`).
+                                    (ft.ret.kind === "promise" &&
+                                        overridden.sig.ret.kind === "promise" &&
+                                        lowerer.promisePayloadWidens(ft.ret, overridden.sig.ret)) ||
+                                    // A JavaScript override's inferred `any` result checks
+                                    // into the inherited type (`toString() { return
+                                    // this.message }` over Error's).
+                                    (ft.ret.kind === "dyn" &&
+                                        isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                                        overridden.sig.ret.kind !== "void" &&
+                                        canDynCheckTo(overridden.sig.ret, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))))) {
+                        returnAdapters.set(mName, { params: [...shapes], ret: ft.ret, async: ownAsync });
+                        shapes.splice(0, shapes.length, ...overridden.sig.params);
+                        ft.ret = overridden.sig.ret;
+                        if (overridden.sig.async === true)
+                            thunkAsyncSlot(overridden, mName);
+                    }
+                    else if (fencedJsOverride) {
                         // A dormant JS method must not poison the whole class. Keep
                         // the inherited call/dispatch ABI and refuse at method entry;
                         // lowering this body with the base signature would change JS.
                         const returnOnly = overridden.sig.params.length === shapes.length &&
                             overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) &&
-                            !member.parameters.some((parameter, index) => {
+                            !member.parameters.nodes.some((parameter, index) => {
                                 if (!parameter.initializer)
                                     return false;
-                                const baseMember = overridden.declarer.decl?.members.find((candidate) => ts.isMethodDeclaration(candidate) &&
+                                const baseMember = overridden.declarer.decl?.members?.nodes.find((candidate) => ts.isMethodDeclaration(candidate) &&
                                     classMemberNameOf(lowerer, candidate.name) === mName);
                                 const inherited = baseMember && ts.isMethodDeclaration(baseMember)
-                                    ? baseMember.parameters[index]?.initializer
+                                    ? baseMember.parameters.nodes[index]?.initializer
                                     : undefined;
                                 if (!inherited)
                                     return false;
@@ -2478,14 +2737,42 @@ mixin) {
                         lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
                 }
-                const asyncMember = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+                // A return narrowed to part of an inherited union returns through
+                // the union ABI; call sites narrow it back to the declared type.
+                if (overridden?.sig.ret.kind === "union" && !typeEquals(ft.ret, overridden.sig.ret)) {
+                    ft.ret = overridden.sig.ret;
+                    lowerer.unionReturnOverrides.add(member);
+                }
+                const asyncMember = member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
                 // Async methods dispatch STATICALLY (the body enters through its
                 // fiber spawn wrapper; vtable slots hold raw implementations) —
                 // an override chain touching an async method on either end would
                 // put a spawn wrapper behind a virtual slot, so it fences.
-                if (overridden && (asyncMember || overridden.sig.async === true)) {
+                // An override chain touching async methods dispatches through
+                // plain slot functions that return the body's promise: the async
+                // bodies lower as `%C.m$own` behind them (thunkAsyncSlot).
+                if (overridden &&
+                    !returnAdapters.has(mName) &&
+                    (asyncMember || overridden.sig.async === true) &&
+                    !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                    !functionLocalClass(decl) &&
+                    member.asteriskToken === undefined &&
+                    overridden.sig.gen === undefined &&
+                    !overridden.sig.abstract &&
+                    ft.ret.kind === "promise" &&
+                    typeEquals(ft.ret, overridden.sig.ret) &&
+                    overridden.sig.params.length === shapes.length &&
+                    overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type) && p.mode === shapes[i].mode)) {
+                    if (overridden.sig.async === true)
+                        thunkAsyncSlot(overridden, mName);
+                    if (asyncMember)
+                        returnAdapters.set(mName, { params: [...shapes], ret: ft.ret, async: true });
+                }
+                if (overridden &&
+                    !returnAdapters.has(mName) &&
+                    (asyncMember || overridden.sig.async === true)) {
                     const message = `overriding ${overridden.sig.async === true ? "the async method" : "a method with an async method"} '${mName}' (async methods dispatch statically — the vtable slot machinery has no fiber-spawn story)`;
-                    if (isJsSourceFile(member.getSourceFile()))
+                    if (isJsSourceFile(ts.getSourceFileOfNode(member)))
                         methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), message));
                     else
                         lowerer.unsupported("SC1090", member.name, message);
@@ -2493,7 +2780,7 @@ mixin) {
                 if (overridden &&
                     (member.asteriskToken !== undefined || overridden.sig.gen !== undefined)) {
                     const message = `overriding the generator method '${mName}' (generator methods dispatch statically — a virtual slot cannot enter their spawn wrapper)`;
-                    if (isJsSourceFile(member.getSourceFile()))
+                    if (isJsSourceFile(ts.getSourceFileOfNode(member)))
                         methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), message));
                     else
                         lowerer.unsupported("SC1090", member.name, message);
@@ -2513,7 +2800,7 @@ mixin) {
                     });
                 }
                 else {
-                    methods.set(mName, asyncMember
+                    methods.set(mName, asyncMember && !returnAdapters.has(mName)
                         ? { params: shapes, ret: ft.ret, async: true }
                         : { params: shapes, ret: ft.ret });
                 }
@@ -2555,7 +2842,7 @@ mixin) {
                     lowerer.unsupported("SC1090", member, "bodyless accessors");
                 const mName = `${isGet ? "get" : "set"}:${prop}`;
                 if (fields.has(prop) &&
-                    isJsSourceFile(decl.getSourceFile()) &&
+                    isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                     base?.fields.has(prop) &&
                     !fieldOrder.some((field) => field.name === prop)) {
                     // JS may override an inherited data field with a prototype
@@ -2572,14 +2859,22 @@ mixin) {
                 }
                 let sig;
                 if (isGet) {
-                    const ret = lowerer.declaredReturnType(member, member.name);
+                    let ret = lowerer.declaredReturnType(member, member.name);
+                    // A getter that never returns a value: typed `never` (it only
+                    // throws, Next.js's removed `page`/`ua` getters) or, unannotated
+                    // with no return statement, inferred `void`. A read answers
+                    // undefined or throws, so the property takes the checked-dynamic
+                    // slot instead of VOID.
+                    if (ret.kind === "void" &&
+                        (lowerer.typeOf(member.name).flags & (ts.TypeFlags.Never | ts.TypeFlags.Void)) !== 0)
+                        ret = DYN;
                     if (ret.kind === "void")
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
                     sig = { params: [], ret };
                 }
                 else {
                     // tsc rejects optional/default/rest setter params (TS1051-53).
-                    sig = { params: lowerer.paramShapes(member.parameters), ret: VOID };
+                    sig = { params: lowerer.paramShapes(member.parameters.nodes), ret: VOID };
                 }
                 if (lowerer.checkedVirtualJsAccessors.has(member)) {
                     if (isGet)
@@ -2643,7 +2938,7 @@ mixin) {
         // undefined. Such fields take the deferred-init representation, whose
         // slot (a nullable instance pointer) starts empty and whose reads check
         // it. Fields assigned before any exposure keep their plain reads.
-        const derived = decl.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ??
+        const derived = decl.heritageClauses?.nodes.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ??
             false;
         // Generic instances and mixins share layouts across declarations, so
         // they only report whether construction exposes the instance.
@@ -2668,7 +2963,7 @@ mixin) {
                     if (!ts.isPropertyAccessExpression(callee))
                         return null;
                     const name = callee.name.text;
-                    const declaration = decl.members.find((member) => ts.isMethodDeclaration(member) &&
+                    const declaration = decl.members.nodes.find((member) => ts.isMethodDeclaration(member) &&
                         member.body !== undefined &&
                         (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                         member.name.text === name);
@@ -2692,7 +2987,7 @@ mixin) {
         const deferredInitFields = new Set(base?.deferredInitFields ?? []);
         if (unguardedFields.length > 0) {
             const topAssigned = new Set();
-            for (const stmt of ctor?.body?.statements ?? []) {
+            for (const stmt of ctor?.body?.statements?.nodes ?? []) {
                 if (ts.isExpressionStatement(stmt) &&
                     ts.isBinaryExpression(stmt.expression) &&
                     stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
@@ -2700,6 +2995,16 @@ mixin) {
                     stmt.expression.left.expression.kind === ts.SyntaxKind.ThisKeyword) {
                     topAssigned.add(stmt.expression.left.name.text);
                 }
+                else if (ts.isExpressionStatement(stmt) &&
+                    ts.isBinaryExpression(stmt.expression) &&
+                    stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isElementAccessExpression(stmt.expression.left) &&
+                    stmt.expression.left.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                    const key = stmt.expression.left.argumentExpression;
+                    const name = classSymbolKeyOf(lowerer, key)?.fieldName ?? lowerer.foldedStringKeyOf(key);
+                    if (name !== null)
+                        topAssigned.add(name);
+                }
             }
             for (const f of unguardedFields) {
                 if (topAssigned.has(f.name) || escape.assigned?.has(f.name))
@@ -2736,13 +3041,26 @@ mixin) {
             }
         }
         if (escape.assigned && !inst) {
+            let earlyReads = null;
             for (const f of fieldOrder) {
                 if (f.redeclared || escape.assigned.has(f.name) || deferredInitFields.has(f.name))
                     continue;
                 if (paramProps.some((pp) => pp.name === f.name))
                     continue;
                 const declared = fields.get(f.name);
-                if (declared?.kind !== "object" || lowerer.classes.get(declared.className)?.def.runtime)
+                // Records, arrays and strings are pointer slots that start empty
+                // too, but only take the checked slot when a method the
+                // constructor calls actually reads them: their other early
+                // exposures keep the plain slot.
+                if (declared?.kind === "record" ||
+                    declared?.kind === "array" ||
+                    declared?.kind === "string") {
+                    earlyReads ??= constructorMethodReads(decl, base, ctor ?? undefined);
+                    if (!earlyReads.has(f.name))
+                        continue;
+                }
+                else if (declared?.kind !== "object" ||
+                    lowerer.classes.get(declared.className)?.def.runtime)
                     continue;
                 const armed = lowerer.withUndefinedArm(declared);
                 if (armed === null || armed.kind !== "union")
@@ -2803,7 +3121,7 @@ mixin) {
         // assignment ran — the zeroed-memory trap a TS declaration order
         // forbids via strictPropertyInitialization — so they keep a named
         // fence instead of reading undefined without a diagnostic.
-        if (isJsSourceFile(decl.getSourceFile())) {
+        if (isJsSourceFile(ts.getSourceFileOfNode(decl))) {
             const hasAccessor = (name) => methods.has(`get:${name}`) ||
                 methods.has(`set:${name}`) ||
                 lowerer.findMethodOn(base, `get:${name}`) !== null ||
@@ -2826,14 +3144,22 @@ mixin) {
             // goes through the key.
             const lateBoundByKey = new Map();
             for (const p of instType ? lowerer.checker.getPropertiesOfType(instType) : []) {
-                if (!p.name.startsWith("__@"))
+                if (!ts.symbolName(p).startsWith("__@"))
                     continue;
                 const keySym = lateBoundKeySymOf(lowerer, p);
                 if (keySym)
                     lateBoundByKey.set(keySym, p);
             }
+            // A subclass field created before anything can observe the instance
+            // keeps its type: super() cannot run code that reads it earlier.
+            const baseConstruction = base && ![...methods.keys()].some((m) => m.startsWith("get:") || m.startsWith("set:"))
+                ? construction(base)
+                : null;
+            const sealedPrefix = baseConstruction
+                ? constructionPrefix(decl, baseConstruction, (name) => !hasAccessor(name) && !methods.has(name) && !lowerer.findMethodOn(base, name))
+                : null;
             if (ctor?.body) {
-                for (const stmt of ctor.body.statements) {
+                for (const stmt of ctor.body.statements.nodes) {
                     const lhs = ts.isExpressionStatement(stmt) &&
                         ts.isBinaryExpression(stmt.expression) &&
                         stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken
@@ -2869,7 +3195,7 @@ mixin) {
                         let type = t ? (lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, assign, t)) : null;
                         if (t &&
                             (t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0 &&
-                            isJsSourceFile(decl.getSourceFile()))
+                            isJsSourceFile(ts.getSourceFileOfNode(decl)))
                             type = DYN;
                         if (type)
                             type = jsOpenObjectType(assign, type, lowerer.shapes, lowerer.unions);
@@ -2901,7 +3227,7 @@ mixin) {
                         type = inheritedJsFieldType(lowerer, decl, name, type);
                         // super() can invoke a subclass setter or method before its
                         // constructor assignments run. These slots start undefined.
-                        if (base && lowerer.dynConvertible(type))
+                        if (base && lowerer.dynConvertible(type) && !sealedPrefix?.created.has(name))
                             type = DYN;
                         fields.set(name, type);
                         fieldOrder.push({ name, type, initializer: undefined });
@@ -2983,17 +3309,16 @@ mixin) {
             // static layouts cannot represent. Named fence, at the first
             // assignment site.
             for (const p of instType ? lowerer.checker.getPropertiesOfType(instType) : []) {
-                if (errorRooted && p.name === "cause")
+                if (errorRooted && ts.symbolName(p) === "cause")
                     continue;
-                if (fields.has(p.name) || methods.has(p.name))
+                if (fields.has(ts.symbolName(p)) || methods.has(ts.symbolName(p)))
                     continue;
-                if (hasAccessor(p.name))
+                if (hasAccessor(ts.symbolName(p)))
                     continue;
-                if (base && (base.fields.has(p.name) || lowerer.findMethodOn(base, p.name)))
+                if (base &&
+                    (base.fields.has(ts.symbolName(p)) || lowerer.findMethodOn(base, ts.symbolName(p))))
                     continue;
-                const site = lowerer.checker
-                    .declarationsOf(p)
-                    .find((d) => ts.isPropertyAccessExpression(d) ||
+                const site = p.declarations.find((d) => ts.isPropertyAccessExpression(d) ||
                     ts.isBinaryExpression(d) ||
                     ts.isElementAccessExpression(d));
                 if (!site)
@@ -3004,7 +3329,7 @@ mixin) {
                 // identities (symbol parameters, mutable bindings, computed
                 // descriptions) or assignments outside the constructor's top
                 // level.
-                if (p.name.startsWith("__@")) {
+                if (ts.symbolName(p).startsWith("__@")) {
                     const keySym = lateBoundKeySymOf(lowerer, p);
                     const key = keySym ? classSymbolKeyOfSymbol(lowerer, keySym) : null;
                     if (key && symbolFields.has(key.identity))
@@ -3021,21 +3346,23 @@ mixin) {
                 // Unmappable inferences and arm-less kinds keep the fence.
                 // TypeScript classes keep the compile-time fence too: an annotated
                 // program can spell `T | undefined` itself.
-                if (isJsSourceFile(decl.getSourceFile())) {
+                if (isJsSourceFile(ts.getSourceFileOfNode(decl))) {
                     const original = undefArmedFieldType(lowerer, p);
-                    const armed = original === null ? null : inheritedJsFieldType(lowerer, decl, p.name, original);
+                    const armed = original === null
+                        ? null
+                        : inheritedJsFieldType(lowerer, decl, ts.symbolName(p), original);
                     if (armed !== null) {
                         // Unknown JS properties use the instance bag: they do not
                         // exist until assigned, and a subclass may declare the same
                         // name as an ordinary layout field.
                         if (armed.kind === "dyn")
                             continue;
-                        fields.set(p.name, armed);
-                        fieldOrder.push({ name: p.name, type: armed, initializer: undefined });
+                        fields.set(ts.symbolName(p), armed);
+                        fieldOrder.push({ name: ts.symbolName(p), type: armed, initializer: undefined });
                         continue;
                     }
                 }
-                lowerer.unsupported("SC1090", site, `fields assigned outside the constructor's top level ('this.${p.name}' would be undefined until the first assignment runs — assign it unconditionally at the top of the constructor)`);
+                lowerer.unsupported("SC1090", site, `fields assigned outside the constructor's top level ('this.${ts.symbolName(p)}' would be undefined until the first assignment runs — assign it unconditionally at the top of the constructor)`);
             }
         }
         // Second refinement chance, OWN symbol slots: the member loop ran
@@ -3059,18 +3386,18 @@ mixin) {
         // is NOT the pure forwarding shape has no static story — named
         // fence, never a mis-typed array.
         const mixinForwarding = mixin !== undefined && ctor !== null && mixinForwardingCtor(lowerer, ctor);
-        if (mixin && ctor && !mixinForwarding && ctor.parameters.some((p) => p.dotDotDotToken)) {
-            lowerer.unsupported("SC1090", ctor.parameters.find((p) => p.dotDotDotToken), "mixin constructors whose rest parameter does anything but forward (`super(...args)` as the first statement is the compiled shape)");
+        if (mixin && ctor && !mixinForwarding && ctor.parameters.nodes.some((p) => p.dotDotDotToken)) {
+            lowerer.unsupported("SC1090", ctor.parameters.nodes.find((p) => p.dotDotDotToken), "mixin constructors whose rest parameter does anything but forward (`super(...args)` as the first statement is the compiled shape)");
         }
         // Constructor omitted on a derived class: it inherits the base's
         // (tsc types `new Derived(...)` against the inherited signature; the
         // synthesized constructor forwards the same params to super).
         const ctorParams = ctor && !mixinForwarding
-            ? lowerer.paramShapes(ctor.parameters)
+            ? lowerer.paramShapes(ctor.parameters.nodes)
             : (base?.ctorParams ?? (callableBase ? [{ type: DYN, mode: "dynRest" }] : []));
         if (ctor &&
             !mixinForwarding &&
-            isJsSourceFile(ctor.getSourceFile()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(ctor)) &&
             !ctorParams.some((shape) => shape.mode === "rest" || shape.mode === "dynRest") &&
             bodyReadsArguments(ctor)) {
             ctorParams.push({ type: DYN, mode: "arguments" });
@@ -3086,9 +3413,9 @@ mixin) {
                 // INSTANTIATION prints its family's name — JS has one `Box`.
                 jsName: jsNameOverride ?? decl.name?.text ?? "",
                 ...(base ? { base: base.def.name } : {}),
-                jsLength: ctor?.parameters.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) === -1
-                    ? ctor.parameters.length
-                    : Math.max(0, ctor?.parameters.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) ?? 0),
+                jsLength: ctor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) === -1
+                    ? ctor.parameters.nodes.length
+                    : Math.max(0, ctor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) ?? 0),
                 // Layout order: the base chain's fields as an IDENTICAL prefix,
                 // then this class's own — what makes an upcast a reinterpret.
                 // Redeclared INHERITED fields contribute no slot (their
@@ -3116,6 +3443,7 @@ mixin) {
             fieldOrder,
             methods,
             ...(methodEntryFences.size > 0 ? { methodEntryFences } : {}),
+            ...(returnAdapters.size > 0 ? { returnAdapters } : {}),
             decl,
             ...(emitOverride !== undefined ? { emitOverride } : {}),
             ctor,
@@ -3138,6 +3466,14 @@ mixin) {
             ...(deferredInitFields.size > 0 ? { deferredInitFields } : {}),
             ...(escape.escapes ? { constructionEscapes: true } : {}),
         };
+        let root = info;
+        while (root?.base)
+            root = root.base;
+        if (root !== info && root?.def.name === "%Error") {
+            const after = errorNameAfterField(info, errorViewFields(info.def.fields));
+            if (after !== undefined)
+                info.def.errorNameAfter = after;
+        }
         // GENERIC members get their declaring-class backlink now that the
         // info exists (instance lowering reads it for `this` typing and the
         // generic-class binding merge).
@@ -3171,7 +3507,7 @@ mixin) {
         }
         if (familyMode) {
             const typeParams = [];
-            for (const tp of decl.typeParameters) {
+            for (const tp of decl.typeParameters.nodes) {
                 const sym = lowerer.checker.getSymbolAtLocation(tp.name);
                 if (!sym)
                     lowerer.unsupported("SC1090", tp, "this type parameter form");
@@ -3439,6 +3775,7 @@ export function lowerStaticFieldInits(lowerer, info) {
     // instantiation's bindings/context (a no-op for everything else —
     // generic FAMILIES own their statics and carry no genericInstance).
     const diagsBefore = lowerer.diags.length;
+    const sinkMark = lowerer.diagSinkMark();
     try {
         return withInstanceBindings(lowerer, info, () => lowerStaticFieldInitsInner(lowerer, info));
     }
@@ -3448,8 +3785,10 @@ export function lowerStaticFieldInits(lowerer, info) {
         // letting a poisoned initializer escape the module lowering pass.
         if (!(error instanceof PoisonError))
             throw error;
-        if (info.decl && isJsSourceFile(info.decl.getSourceFile()) && lowerer.diagSink === null) {
-            const fence = lowerer.deferToRuntimeFence(diagsBefore, info.decl, { kind: "statement" });
+        if (info.decl && isJsSourceFile(ts.getSourceFileOfNode(info.decl))) {
+            const fence = lowerer.diagSink === null
+                ? lowerer.deferToRuntimeFence(diagsBefore, info.decl, { kind: "statement" })
+                : lowerer.capturedRuntimeFence(sinkMark, info.decl);
             if (fence)
                 return [fence];
         }
@@ -3560,8 +3899,16 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         });
     }
     const items = [
-        ...info.staticFields.map((f) => ({ pos: f.initializer.getStart(), kind: "field", f })),
-        ...(info.staticBlocks ?? []).map((b) => ({ pos: b.getStart(), kind: "block", b })),
+        ...info.staticFields.map((f) => ({
+            pos: ts.tokenStartOfNode(f.initializer),
+            kind: "field",
+            f,
+        })),
+        ...(info.staticBlocks ?? []).map((b) => ({
+            pos: ts.tokenStartOfNode(b),
+            kind: "block",
+            b,
+        })),
     ].sort((a, b) => a.pos - b.pos);
     for (const item of items) {
         if (item.kind === "block") {
@@ -3571,9 +3918,9 @@ function lowerStaticFieldInitsInner(lowerer, info) {
             continue;
         }
         const f = item.f;
-        lowerer.stats.statementsTotal++;
-        lowerer.bumpFileStat(locOf(f.initializer).file, "total");
+        lowerer.countStatement(f.initializer, locOf(f.initializer).file);
         const diagsBefore = lowerer.diags.length;
+        const sinkMark = lowerer.diagSinkMark();
         try {
             const previousThis = lowerer.ctx.thisLocal;
             const receiver = f.initializer.kind === ts.SyntaxKind.ThisKeyword || hasStaticThis(f.initializer)
@@ -3610,12 +3957,11 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
-            lowerer.stats.statementsFailed++;
-            lowerer.bumpFileStat(locOf(f.initializer).file, "failed");
-            if (isJsSourceFile(f.initializer.getSourceFile()) && lowerer.diagSink === null) {
-                const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, {
-                    kind: "statement",
-                });
+            lowerer.countStatementFailed(f.initializer, locOf(f.initializer).file);
+            if (isJsSourceFile(ts.getSourceFileOfNode(f.initializer))) {
+                const fence = lowerer.diagSink === null
+                    ? lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { kind: "statement" })
+                    : lowerer.capturedRuntimeFence(sinkMark, f.initializer);
                 if (fence)
                     out.push(fence);
             }
@@ -3664,12 +4010,12 @@ export function analyzeClassDecoration(lowerer, info) {
                     : null;
             if (ambientCallee !== null) {
                 const sym = lowerer.resolveValueSymbol(ambientCallee);
-                const vdecl = sym && !lowerer.isStdlibSymbol(sym) ? lowerer.checker.declarationsOf(sym)[0] : undefined;
+                const vdecl = sym && !lowerer.isStdlibSymbol(sym) ? sym.declarations[0] : undefined;
                 const ambientVar = vdecl !== undefined &&
                     ts.isVariableDeclaration(vdecl) &&
                     vdecl.initializer === undefined &&
                     (ts.getCombinedModifierFlags(vdecl) & ts.ModifierFlags.Ambient) !== 0 &&
-                    !vdecl.getSourceFile().isDeclarationFile;
+                    !ts.getSourceFileOfNode(vdecl).isDeclarationFile;
                 if (ambientVar || ambientUndefinedFnSymbolOf(lowerer, ambientCallee) !== null) {
                     shapes.push({ kind: "ambientThrow", name: ambientCallee.text });
                     continue;
@@ -3861,6 +4207,54 @@ export function staticShadowBelow(info, name) {
         s.genericStatics?.has(name) === true ||
         staticShadowBelow(s, name));
 }
+/** The `this` members read by the methods and accessors a constructor
+ * calls through `this` (transitively, over the class and its bases),
+ * outside nested functions. The constructor's own reads are not included:
+ * they run where the constructor's statements put them. */
+function constructorMethodReads(decl, base, ctor) {
+    const reads = new Set();
+    const visited = new Set();
+    const bodies = (name) => {
+        const out = [];
+        let owner = decl;
+        for (let next = base; owner; owner = next?.decl ?? undefined, next = next?.base ?? null) {
+            for (const member of owner.members.nodes) {
+                if ((ts.isMethodDeclaration(member) || ts.isAccessor(member)) &&
+                    member.body &&
+                    (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
+                    member.name.text === name)
+                    out.push(member.body);
+            }
+        }
+        return out;
+    };
+    const enter = (name) => {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        for (const body of bodies(name))
+            scan(body, true);
+    };
+    // Nested functions (callbacks handed elsewhere) are not followed: only
+    // the straight-line code of the constructor and the methods it calls.
+    const scan = (node, inMethod) => {
+        ts.walkPreorder(node, (n) => {
+            if (n !== node && ts.isFunctionLike(n))
+                return "skip";
+            if (ts.isPropertyAccessExpression(n) &&
+                n.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                (ts.isIdentifier(n.name) || ts.isPrivateIdentifier(n.name))) {
+                if (inMethod)
+                    reads.add(n.name.text);
+                enter(n.name.text);
+            }
+            return undefined;
+        });
+    };
+    if (ctor?.body)
+        scan(ctor.body, false);
+    return reads;
+}
 /** The nearest GENERIC static declaration of `name` at/above `info` —
  * findStaticOn's twin over the genericStatics tables. */
 export function findGenericStaticOn(lowerer, info, name) {
@@ -3915,17 +4309,22 @@ export function classValueRef(lowerer, info, blame) {
         lowerer.unsupported("SC1090", blame, `generic classes as values ('typeof ${display}' keeps the type parameter — instantiation expressions ('${display}<number>') and concrete constructor-typed slots compile)`);
     }
     if (info.builtinError || info.builtinEmitter || info.builtinStream !== undefined) {
-        lowerer.unsupported("SC1090", blame, `builtin classes as values ('${display}' is runtime-provided — reference program-declared classes instead)`);
-    }
-    if (lowerer.inheritsBuiltinEmitterCtor(info) ||
-        inheritsBuiltinStreamCtor(lowerer, info) ||
-        eventTargetRootOf(info) !== null ||
-        (() => {
-            for (let c = info.base; c; c = c.base)
-                if (c.builtinEmitter || c.builtinStream !== undefined)
-                    return true;
-            return false;
-        })()) {
+        if (info.valueCtorParams === undefined) {
+            lowerer.unsupported("SC1090", blame, `builtin classes as values ('${display}' is runtime-provided — reference program-declared classes instead)`);
+        }
+        defineClassValueConstruct(lowerer, info);
+        return {
+            kind: "classRef",
+            className: info.def.name,
+            type: { kind: "classval", className: info.def.name },
+            loc: locOf(blame),
+        };
+    }
+    // Classes extending EventEmitter or a stream class construct through
+    // their own (or synthesized) `%C.constructor`, whose super call runs the
+    // runtime initializer, so the class object's construct thunk serves them
+    // like any program class. EventTarget subclasses keep the refusal.
+    if (eventTargetRootOf(info) !== null) {
         lowerer.unsupported("SC1090", blame, `classes extending builtin bases as values ('${display}' inherits a runtime-provided constructor)`);
     }
     lowerer.noteEdge(`%${info.def.name}.constructor`);
@@ -3936,14 +4335,94 @@ export function classValueRef(lowerer, info, blame) {
         loc: locOf(blame),
     };
 }
+/** Notes a runtime-provided class whose value is named, widened to, or
+ * constructed through (a no-op for program classes, whose constructor is
+ * their own). runtimeClassConstructs defines `%C.construct` for the
+ * noted classes the finished module still references. */
+export function defineClassValueConstruct(lowerer, info) {
+    if (!info.def.runtime || info.valueCtorParams === undefined)
+        return;
+    lowerer.noteEdge(classValueConstructor(info.def).fn);
+    lowerer.runtimeClassValues.set(info.def.name, info);
+}
+/** The `%C.construct` functions of the noted runtime classes that a
+ * classRef, newValue or classval upcast in `functions` names. Lowering can
+ * name a class speculatively and discard the expression, so the finished
+ * functions decide. */
+export function runtimeClassConstructs(lowerer, functions) {
+    if (lowerer.runtimeClassValues.size === 0)
+        return [];
+    const used = new Set();
+    const note = (type) => {
+        if (type.kind === "classval" && lowerer.runtimeClassValues.has(type.className))
+            used.add(type.className);
+    };
+    const visitor = {
+        expr: (e) => {
+            if (e.kind === "classRef")
+                note(e.type);
+            else if (e.kind === "newValue")
+                note(e.callee.type);
+            else if (e.kind === "upcast") {
+                note(e.type);
+                note(e.value.type);
+            }
+            return true;
+        },
+        stmt: () => true,
+    };
+    for (const fn of functions)
+        everyStmtList(fn.body, visitor);
+    return [...used]
+        .sort()
+        .map((name) => runtimeClassConstruct(lowerer.runtimeClassValues.get(name)));
+}
+/** `%C.construct` for a runtime-provided class value: the thunk's target,
+ * which builds the instance through the runtime constructor the direct
+ * `new C(...)` uses (emitter.new, a stream's .newDyn without options,
+ * error.newOptions). */
+function runtimeClassConstruct(info) {
+    const params = info.valueCtorParams ?? [];
+    const name = classValueConstructor(info.def).fn;
+    const loc = info.def.loc;
+    const type = { kind: "object", className: info.def.name };
+    const ids = params.map((_, i) => `a${i}.0`);
+    const args = ids.map((id) => varRef(id, DYN, loc));
+    let fn = "error.newOptions";
+    if (info.builtinEmitter)
+        fn = "emitter.new";
+    else if (info.builtinStream !== undefined) {
+        fn = `${streamCtorShape(info.def.name).fn}.newDyn`;
+        args.push(dynUndefinedExpr(loc));
+    }
+    return {
+        name,
+        params: params.map((shape, i) => ({ localId: ids[i], name: `a${i}`, type: shape.type })),
+        returnType: type,
+        locals: params.map((shape, i) => ({
+            id: ids[i],
+            name: `a${i}`,
+            type: shape.type,
+            mutable: false,
+        })),
+        body: [{ kind: "return", value: { kind: "libCall", fn, args, type, loc }, loc }],
+        loc,
+    };
+}
+/** The constructor parameters construction through a class value completes
+ * against: a program class's constructor, or a runtime class's
+ * `%C.construct`. */
+function classValueParams(info) {
+    return info.def.runtime ? (info.valueCtorParams ?? info.ctorParams) : info.ctorParams;
+}
 /** Constructor-ABI equality — the classval widening rule: a classval(D)
  * value may flow into a classval(C) slot only when D's completed
  * constructor signature equals C's (same count, modes, and ABI types),
  * which is what keeps newValue completion against C's one signature
  * sound for every value legally in the slot. */
 export function ctorAbiEquals(lowerer, sub, sup) {
-    const a = sub.ctorParams;
-    const b = sup.ctorParams;
+    const a = classValueParams(sub);
+    const b = classValueParams(sup);
     return (a.length === b.length &&
         a.every((p, i) => p.mode === b[i].mode && typeEquals(p.type, b[i].type)));
 }
@@ -4042,8 +4521,18 @@ export function lowerStaticFieldRead(lowerer, expr) {
     }
     // `C.name` — the JS-observable class name, a compile-time constant on
     // the direct spelling (tsc rejects user statics named `name`, so the
-    // chain above can never shadow it in TypeScript sources).
+    // chain above can never shadow it in TypeScript sources). A class of an
+    // import cycle reads it from its class object instead, whose reference
+    // checks the class's initialization (checkCycleBindingAccesses).
     if (expr.name.text === "name" && info.def.jsName !== undefined) {
+        if (lowerer.classInitFlags.get(info.def.name)?.cycle === true)
+            return {
+                kind: "libCall",
+                fn: "class.name",
+                args: [classValueRef(lowerer, info, expr.expression)],
+                type: STRING,
+                loc,
+            };
         return { kind: "strLit", value: info.def.jsName, type: STRING, loc };
     }
     if (info.callableBase)
@@ -4066,7 +4555,7 @@ export function lowerStaticFieldRead(lowerer, expr) {
         // JavaScript often assigns public statics after the class declaration.
         // Their storage stays mutable and checked, while reads retain the
         // checker's concrete type instead of losing the method receiver.
-        const type = isJsSourceFile(expr.getSourceFile())
+        const type = isJsSourceFile(ts.getSourceFileOfNode(expr))
             ? null
             : lowerer.mapTypeOf(lowerer.typeOf(expr));
         return type ? lowerer.coerceToExpected(value, type) : value;
@@ -4097,6 +4586,70 @@ function namedEvaluationName(expr) {
         return p.name.text;
     return "";
 }
+/** Each evaluation of a function-local class creates fresh private names,
+ * while the compiled class shares one layout across evaluations. A
+ * JavaScript class's prototype methods are closures per evaluation, so the
+ * names agree when every private member is an instance field and every use
+ * is on `this` (privateNamesOnlyOnThis): native methods only run on their
+ * own evaluation's instances, and the closures, which receive any `this`,
+ * check the receiver's evaluation against the class's own binding
+ * (private-brands.ts), so the class must be a named declaration (undici's
+ * webidl FastIterableIterator). The checker rejects writes to that binding. */
+function localPrivateFieldsAgree(expr) {
+    if (!isJsSourceFile(ts.getSourceFileOfNode(expr)) || !ts.isClassDeclaration(expr) || !expr.name)
+        return false;
+    if (expr.members.nodes.some((member) => member.name !== undefined &&
+        ts.isPrivateIdentifier(member.name) &&
+        !ts.isPropertyDeclaration(member)))
+        return false;
+    return privateNamesOnlyOnThis(expr);
+}
+/** Every private name is used only on `this` inside the class's own instance
+ * members (`this.#x`, `#x in this`), outside nested classes and non-arrow
+ * functions, and the class has no static members that could hand instances
+ * across evaluations. */
+function privateNamesOnlyOnThis(expr) {
+    let ok = true;
+    for (const member of expr.members.nodes) {
+        if (ts.getModifiers(member)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword))
+            return false;
+        ts.walkPreorder(member, (node) => {
+            if (!ok)
+                return "stop";
+            // A nested class or non-arrow function rebinds `this`: any private
+            // name inside it disqualifies.
+            if (node !== member &&
+                (ts.isClassDeclaration(node) ||
+                    ts.isClassExpression(node) ||
+                    ts.isFunctionExpression(node) ||
+                    ts.isFunctionDeclaration(node))) {
+                ts.walkPreorder(node, (inner) => {
+                    if (ts.isPrivateIdentifier(inner))
+                        ok = false;
+                    return ok ? undefined : "stop";
+                });
+                return "skip";
+            }
+            if (ts.isPrivateIdentifier(node)) {
+                const parent = node.parent;
+                const onThis = parent === member ||
+                    (ts.isPropertyAccessExpression(parent) &&
+                        parent.name === node &&
+                        parent.expression.kind === ts.SyntaxKind.ThisKeyword) ||
+                    (ts.isBinaryExpression(parent) &&
+                        parent.left === node &&
+                        parent.operatorToken.kind === ts.SyntaxKind.InKeyword &&
+                        parent.right.kind === ts.SyntaxKind.ThisKeyword);
+                if (!onThis)
+                    ok = false;
+            }
+            return undefined;
+        });
+        if (!ok)
+            return false;
+    }
+    return true;
+}
 /** Collect a class expression once per enclosing specialization. Function-local
  * evaluations allocate fresh constructor objects; top-level expressions use
  * immortal templates. Static initialization remains limited to whole top-level
@@ -4123,19 +4676,21 @@ export function lowerClassExpressionInfo(lowerer, expr) {
         if (ts.isFunctionLike(p))
             local = true;
     }
-    if (local && expr.members.some((member) => member.name && ts.isPrivateIdentifier(member.name))) {
+    if (local &&
+        expr.members.nodes.some((member) => member.name && ts.isPrivateIdentifier(member.name)) &&
+        !localPrivateFieldsAgree(expr)) {
         lowerer.unsupported("SC1090", expr, "function-local classes with private brands");
     }
     if (local &&
-        (expr.typeParameters?.length ||
+        (expr.typeParameters?.nodes.length ||
             decoratorNodesOf(expr).length ||
-            expr.members.some((member) => decoratorNodesOf(member).length ||
-                (!isJsSourceFile(expr.getSourceFile()) &&
+            expr.members.nodes.some((member) => decoratorNodesOf(member).length ||
+                (!isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
                     (ts.isClassStaticBlockDeclaration(member) ||
                         ts
                             .getModifiers(member)
                             ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) ||
-                (ts.isMethodDeclaration(member) && member.typeParameters?.length)))) {
+                (ts.isMethodDeclaration(member) && member.typeParameters?.nodes.length)))) {
         lowerer.unsupported("SC1090", expr, "function-local classes with statics, decorators, or generic members");
     }
     lowerer.collectingExprClasses.add(expr);
@@ -4143,9 +4698,9 @@ export function lowerClassExpressionInfo(lowerer, expr) {
         if (local &&
             lowerer.fnStack.length > 0 &&
             !lowerer.computedClassBases.has(lowerer.classNamer(expr))) {
-            const heritage = expr.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+            const heritage = expr.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
             if (heritage &&
-                (ts.isCallExpression(heritage) ||
+                ((ts.isCallExpression(heritage) && !builtinRequireBaseOf(lowerer, heritage)) ||
                     (ts.isIdentifier(heritage) &&
                         (lowerer.peekLocal(heritage) ?? lowerer.globalOf(heritage)) != null))) {
                 let value = lowerer.lowerExpr(heritage);
@@ -4175,7 +4730,7 @@ export function lowerClassExpressionInfo(lowerer, expr) {
         });
         info.localClass = { context: null, bodies: new Map(), captureSources: [], ready: false };
         if (info.base?.localClass) {
-            const baseExpression = expr.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+            const baseExpression = expr.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
             if (baseExpression)
                 info.localClass.baseExpression = baseExpression;
         }
@@ -4206,7 +4761,7 @@ export function lowerClassExpressionInfo(lowerer, expr) {
         const wholeInit = (ts.isVariableDeclaration(holder) &&
             holder.initializer !== undefined &&
             ts.isVariableDeclarationList(holder.parent) &&
-            holder.parent.declarations.length === 1 &&
+            holder.parent.declarations.nodes.length === 1 &&
             ts.isVariableStatement(holder.parent.parent) &&
             ts.isSourceFile(holder.parent.parent.parent)) ||
             (ts.isBinaryExpression(holder) &&
@@ -4230,8 +4785,8 @@ export function lowerClassExpressionInfo(lowerer, expr) {
  * the member fences don't apply. */
 export function lowerClassExpression(lowerer, expr) {
     if (decoratorNodesOf(expr).length > 0 ||
-        expr.members.some((m) => decoratorNodesOf(m).length > 0)) {
-        if (!isJsSourceFile(expr.getSourceFile()) && expr.typeParameters === undefined) {
+        expr.members.nodes.some((m) => decoratorNodesOf(m).length > 0)) {
+        if (!isJsSourceFile(ts.getSourceFileOfNode(expr)) && expr.typeParameters === undefined) {
             const thrown = guaranteedDecorationThrow(lowerer, expr);
             if (thrown) {
                 // The expression's static type never materializes — the read
@@ -4413,7 +4968,7 @@ export function exactClassOfReceiver(lowerer, expr) {
     // class-value write fence answers instead.
     if (direct)
         return direct.classDecorators?.valueGlobalId !== undefined ? null : direct;
-    const decl = lowerer.checker.valueDeclarationOf(symbol);
+    const decl = symbol.valueDeclaration;
     if (!decl ||
         !ts.isVariableDeclaration(decl) ||
         decl.initializer === undefined ||
@@ -4457,7 +5012,7 @@ export function propertyAssignedClassInfoOf(lowerer, symbol) {
     const registered = lowerer.classBySymbol.get(resolved);
     if (registered)
         return registered;
-    const decls = lowerer.checker.declarationsOf(resolved);
+    const decls = resolved.declarations;
     // The class expression's OWN symbol (tsgo's answer through CJS export
     // aliases): the declaration is the expression itself. Its top-level
     // assignment statement must be the binding's ONLY producer. The
@@ -4511,17 +5066,17 @@ function enclosingTopLevelClassAssignment(expr) {
  * `Common.I`): a second assignment makes the binding dynamic, so
  * callers refuse to pin the first one's class. */
 function countAssignmentsTo(assign) {
-    const sf = assign.getSourceFile();
+    const sf = ts.getSourceFileOfNode(assign);
     // `exports.I` and `module.exports.I` are the SAME binding in Node
     // (exports aliases module.exports until a table replaces it) — fold
     // the member spellings together before comparing.
     const canon = (lhs) => {
-        const text = lhs.getText().replace(/\s+/g, "");
+        const text = ts.getTextOfNode(lhs).replace(/\s+/g, "");
         return text.startsWith("module.exports.") ? text.slice("module.".length) : text;
     };
     const target = canon(assign.left);
     let n = 0;
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         if (!ts.isExpressionStatement(stmt))
             continue;
         const e = stmt.expression;
@@ -4569,9 +5124,9 @@ export function lowerStaticMethodCall(lowerer, call, access) {
     // export assignment pins it) — the direct-name rules apply.
     if (!ts.isIdentifier(access.expression)) {
         if (!isModuleExportsAccess(access.expression) ||
-            !isCjsJsFile(access.getSourceFile(), lowerer.program)) {
+            !isCjsJsFile(ts.getSourceFileOfNode(access), lowerer.program)) {
             let receiverType = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-            if (receiverType?.kind !== "classval" && isJsSourceFile(call.getSourceFile())) {
+            if (receiverType?.kind !== "classval" && isJsSourceFile(ts.getSourceFileOfNode(call))) {
                 const receiver = tryLowerExpression(lowerer, access.expression);
                 if (receiver?.type.kind === "classval")
                     receiverType = receiver.type;
@@ -4596,7 +5151,7 @@ export function lowerStaticMethodCall(lowerer, call, access) {
                 loc: locOf(call),
             };
         }
-        const whole = cjsClassExprWholeExportOf(access.getSourceFile());
+        const whole = cjsClassExprWholeExportOf(ts.getSourceFileOfNode(access));
         if (!whole)
             return null;
         return staticCallOn(lowerer, call, access, lowerer.lowerClassExpressionInfo(whole.classExpr), false);
@@ -4637,6 +5192,9 @@ function classValueIsExactlyOwn(lowerer, recv, info) {
 }
 function staticCallOn(lowerer, call, access, info, throughValue) {
     const loc = locOf(call);
+    const runtimeStatic = directRuntimeStaticCall(lowerer, call, access, info, throughValue);
+    if (runtimeStatic)
+        return runtimeStatic;
     if ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, access.name.text)?.field) ||
         (info.callableBase &&
             !findStaticOn(lowerer, info, access.name.text) &&
@@ -4646,7 +5204,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
             recv: lowerer.lowerExprExpecting(access.expression, DYN),
             method: access.name.text,
             calleeName: access.name.text,
-            args: call.arguments.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
+            args: call.arguments.nodes.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
             type: DYN,
             loc,
         };
@@ -4676,7 +5234,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
             lowerer.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
         }
         const instance = genericCallInstance(lowerer, call, staticMethodForReceiver(lowerer, access, gfound.info, info, throughValue));
-        const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
+        const args = lowerer.completeArgs(call.arguments.nodes, instance.params, loc, call);
         return { kind: "call", callee: instance.name, args, type: instance.returnType, loc };
     }
     if (throughValue && staticShadowBelow(info, access.name.text)) {
@@ -4685,7 +5243,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
     const specialized = findGenericStaticOn(lowerer, info, access.name.text);
     if (specialized?.declarer === found.declarer && specialized.info.implicitParams) {
         const instance = implicitCallInstance(lowerer, call, staticMethodForReceiver(lowerer, access, specialized.info, info, throughValue));
-        const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
+        const args = lowerer.completeArgs(call.arguments.nodes, instance.params, loc, call);
         return { kind: "call", callee: instance.name, args, type: instance.returnType, loc };
     }
     if (found.field !== undefined) {
@@ -4700,7 +5258,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
             loc,
         };
         const params = found.field.type.params;
-        const args = call.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
+        const args = call.arguments.nodes.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
         for (let i = args.length; i < params.length; i++) {
             const absent = omittedArgFor(lowerer, params[i], loc);
             if (!absent) {
@@ -4730,16 +5288,184 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         return {
             kind: "call",
             callee: instance.name,
-            args: lowerer.completeArgs(call.arguments, instance.params, loc, call),
+            args: lowerer.completeArgs(call.arguments.nodes, instance.params, loc, call),
             type: instance.returnType,
             loc,
         };
     }
     const fnName = `%${found.declarer.def.name}.static:${access.name.text}`;
     lowerer.noteEdge(fnName);
-    const args = lowerer.completeArgs(call.arguments, found.method.params, loc, call);
+    const args = lowerer.completeArgs(call.arguments.nodes, found.method.params, loc, call);
     return { kind: "call", callee: fnName, args, type: found.method.ret, loc };
 }
+/** `C.m(...)` where `m` is a static method that a function-local
+ * JavaScript class defines at runtime (a factory's `class extends base`),
+ * inherited by `C` through its statically known base chain. When the body
+ * captures nothing from the factory's scope, every evaluation of the class
+ * defines the same method, so the call lowers directly with `this` bound
+ * to `C`, as a free function given `C` would. A receiver-dependent result
+ * (a class built from `this`) then keeps a static base. Null when another
+ * declaration of `m` answers first, the program assigns that member, or
+ * the method form has no direct lowering. */
+function directRuntimeStaticCall(lowerer, call, access, info, throughValue) {
+    const name = access.name.text;
+    if (throughValue || name.startsWith("#"))
+        return null;
+    let declarer = null;
+    let member = null;
+    for (let c = info; c; c = c.base) {
+        if (c.staticFields.some((field) => field.name === name) ||
+            c.staticMethods?.has(name) === true ||
+            c.genericStatics?.has(name) === true)
+            return null;
+        const runtime = c.runtimeStatics?.find((element) => element.name !== undefined &&
+            ts.isIdentifier(element.name) &&
+            element.name.text === name);
+        if (runtime) {
+            if (!ts.isMethodDeclaration(runtime) || !runtime.body)
+                return null;
+            declarer = c;
+            member = runtime;
+            break;
+        }
+    }
+    if (!declarer || !member || !declarer.decl)
+        return null;
+    if (member.asteriskToken || member.typeParameters?.nodes)
+        return null;
+    if (member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword))
+        return null;
+    if (hasLexicalSuper(member) || capturesEnclosingScope(lowerer, member, declarer.decl))
+        return null;
+    if (memberAssigned(lowerer, member, name) || bodyReadsArguments(member))
+        return null;
+    const implicit = member.parameters.nodes.length === 0 ? null : implicitAnyParamSymbolsOf(lowerer, member, true);
+    if (member.parameters.nodes.length > 0 && !implicit)
+        return null;
+    let calls = declarer.runtimeStaticCalls;
+    if (!calls) {
+        calls = new Map();
+        declarer.runtimeStaticCalls = calls;
+    }
+    const method = calls.get(name) ?? {
+        decl: member,
+        baseName: name,
+        qualifiedName: `%${declarer.def.name}.runtimeStatic:${name}`,
+        typeParams: [],
+        instances: new Map(),
+        member: { cls: declarer, kind: "static" },
+        ...(implicit ? { implicitParams: implicit } : {}),
+    };
+    calls.set(name, method);
+    // A direct lowering the method form does not support keeps the dynamic
+    // call: its refusal is not this program's error.
+    const sink = [];
+    const previousSink = lowerer.diagSink;
+    lowerer.diagSink = sink;
+    let lowered;
+    try {
+        const receiver = staticMethodForReceiver(lowerer, access, method, info, false);
+        const instance = implicit
+            ? implicitCallInstance(lowerer, call, receiver)
+            : genericCallInstance(lowerer, call, receiver);
+        lowered = {
+            kind: "call",
+            callee: instance.name,
+            args: lowerer.completeArgs(call.arguments.nodes, instance.params, locOf(call), call),
+            type: instance.returnType,
+            loc: locOf(call),
+        };
+    }
+    catch (error) {
+        if (error instanceof PoisonError)
+            return null;
+        throw error;
+    }
+    finally {
+        lowerer.diagSink = previousSink;
+    }
+    return sink.length === 0 ? lowered : null;
+}
+/** `super` inside the method (arrows included) names the defining
+ * class's base, which a receiver specialization does not track. */
+function hasLexicalSuper(root) {
+    let found = false;
+    const visit = (node) => {
+        if (node.kind === ts.SyntaxKind.SuperKeyword)
+            found = true;
+        if ((ts.isFunctionLike(node) && !ts.isArrowFunction(node)) ||
+            ts.isClassDeclaration(node) ||
+            ts.isClassExpression(node))
+            return;
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(root, visit);
+    return found;
+}
+/** The method reads a binding declared in a function that encloses its
+ * class: each evaluation of the class can see a different value. */
+function capturesEnclosingScope(lowerer, member, classDecl) {
+    let scope = classDecl.parent;
+    while (scope && !ts.isFunctionLike(scope) && !ts.isSourceFile(scope))
+        scope = scope.parent;
+    if (!scope || ts.isSourceFile(scope))
+        return false;
+    const inside = (node, container) => {
+        for (let n = node; n; n = n.parent)
+            if (n === container)
+                return true;
+        return false;
+    };
+    let captured = false;
+    const visit = (node) => {
+        if (captured)
+            return;
+        if (ts.isIdentifier(node)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(node);
+            const decl = symbol ? symbol.valueDeclaration : undefined;
+            // The enclosing function's own name is the same binding for every
+            // evaluation.
+            if (decl && decl !== scope && inside(decl, scope) && !inside(decl, member))
+                captured = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(member, visit);
+    return captured;
+}
+/** Some code assigns or deletes a member of this name, or defines it by
+ * reflection: the member a runtime lookup finds can then differ. */
+function memberAssigned(lowerer, member, name) {
+    let found = false;
+    for (const sf of lowerer.program.getSourceFiles()) {
+        if (sf.isDeclarationFile || found)
+            continue;
+        if (!sf.text.includes(name))
+            continue;
+        ts.walkPreorder(sf, (node) => {
+            if (found)
+                return "skip";
+            if (ts.isPropertyAccessExpression(node) && node.name.text === name) {
+                const parent = node.parent;
+                if (parent &&
+                    ((ts.isBinaryExpression(parent) &&
+                        parent.left === node &&
+                        parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                        parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment) ||
+                        ts.isDeleteExpression(parent)))
+                    found = true;
+            }
+            if (ts.isStringLiteral(node) && node.text === name && node !== member.name) {
+                const parent = node.parent;
+                if (parent && (ts.isCallExpression(parent) || ts.isElementAccessExpression(parent)))
+                    found = true;
+            }
+            return undefined;
+        });
+    }
+    return found;
+}
 function staticMethodForReceiver(lowerer, access, method, receiver, throughValue) {
     if (!hasStaticThis(method.decl))
         return method;
@@ -4782,6 +5508,10 @@ export function lowerClassValueProperty(lowerer, expr) {
     const loc = locOf(expr);
     const member = expr.name.text;
     const info = lowerer.classes.get(recvT.className);
+    // A runtime-provided class value answers `.name` from its class object;
+    // its other statics (`Error.stackTraceLimit`) keep their own lowerings.
+    if (info?.def.runtime && member !== "name")
+        return null;
     if (info &&
         ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, member)?.field) ||
             (info.callableBase && !findStaticOn(lowerer, info, member))))
@@ -4808,7 +5538,8 @@ export function lowerClassValueProperty(lowerer, expr) {
         // `module.exports.label` in a class-replaced CJS module: the
         // receiver is the exact exported class, and the read is
         // side-effect-free — as bindable as an identifier.
-        !(isModuleExportsAccess(expr.expression) && isCjsJsFile(expr.getSourceFile(), lowerer.program))) {
+        !(isModuleExportsAccess(expr.expression) &&
+            isCjsJsFile(ts.getSourceFileOfNode(expr), lowerer.program))) {
         // Devirtualized reads DISCARD the receiver value, so only
         // side-effect-free receivers are claimed (the instanceOf fold
         // rule); computed ones meet the pointed fence with a bindable fix.
@@ -4855,19 +5586,56 @@ export function lowerClassValueProperty(lowerer, expr) {
  * async/generator/generic-with-body combinations before this runs, and
  * the generic case fences at the caller). */
 function abstractMemberSignature(lowerer, member) {
-    for (const param of member.parameters) {
+    for (const param of member.parameters.nodes) {
         if (!ts.isIdentifier(param.name))
             lowerer.unsupported("SC1031", param);
     }
     return {
-        shapes: lowerer.paramShapes(member.parameters),
+        shapes: lowerer.paramShapes(member.parameters.nodes),
         ret: lowerer.declaredReturnType(member, member.name),
     };
 }
 /** A nominal return subtype uses the same owned pointer as the inherited
  * return slot. The current class is still being collected, so consult its
  * already collected base chain before the complete class graph is available. */
+/** An inherited ASYNC method that an override now dispatches against: its
+ * slot becomes a plain function returning the body's promise, and the
+ * async body lowers behind it as `%C.m$own` (the adapter path with an
+ * identity conversion), so a virtual call never enters an async body
+ * without its spawn wrapper. */
+function thunkAsyncSlot(overridden, mName) {
+    if (overridden.sig.async !== true)
+        return;
+    const declarer = overridden.declarer;
+    // The slot answers the body's promise: an untyped async method's `dyn`
+    // result is the promise's payload, so the slot's ABI is that promise. An
+    // async generator method's slot keeps its generator object.
+    const ret = overridden.sig.gen || overridden.sig.ret.kind === "promise"
+        ? overridden.sig.ret
+        : { kind: "promise", inner: overridden.sig.ret };
+    declarer.returnAdapters ??= new Map();
+    if (!declarer.returnAdapters.has(mName)) {
+        declarer.returnAdapters.set(mName, {
+            params: [...overridden.sig.params],
+            ret,
+            async: true,
+        });
+    }
+    overridden.sig.ret = ret;
+    delete overridden.sig.async;
+}
 function overrideReturnAbi(lowerer, declared, inherited, className, base) {
+    // A return narrowed to part of an inherited union (`Meta` for
+    // `Meta | undefined`) keeps the union ABI; returns convert into it.
+    if (inherited.kind === "union" && !typeEquals(declared, inherited)) {
+        const arms = lowerer.unions.get(inherited.unionId)?.arms ?? [];
+        const fits = (type) => arms.some((arm) => typeEquals(arm, type) ||
+            (arm.kind === "object" &&
+                type.kind === "object" &&
+                lowerer.isSubclassOf(type.className, arm.className)));
+        const parts = declared.kind === "union" ? (lowerer.unions.get(declared.unionId)?.arms ?? []) : [declared];
+        return parts.length > 0 && parts.every(fits) ? inherited : declared;
+    }
     if (declared.kind !== "object" || inherited.kind !== "object")
         return declared;
     if (lowerer.isSubclassOf(declared.className, inherited.className) ||
@@ -4947,7 +5715,7 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
             continue;
         ts.walkPreorder(file, (node) => {
             if ((!ts.isClassDeclaration(node) && !ts.isClassExpression(node)) ||
-                !node.heritageClauses?.length)
+                !node.heritageClauses?.nodes.length)
                 return;
             const writes = new Map();
             const addWrite = (name, expression) => {
@@ -4974,10 +5742,10 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
                             addWrite(name, part.right);
                     }
                 }
-                part.forEachChild(scan);
+                ts.forEachChild(part, scan);
             };
-            for (const member of node.members) {
-                if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))
+            for (const member of node.members.nodes) {
+                if (member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))
                     continue;
                 if (ts.isPropertyDeclaration(member) && member.initializer) {
                     const name = ts.isPrivateIdentifier(member.name)
@@ -5007,7 +5775,7 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
                 for (const base of lowerer.checker.getBaseTypes(target)) {
                     for (const [name, expressions] of writes) {
                         const property = lowerer.checker.getPropertyOfType(base, name);
-                        for (const declaration of property ? lowerer.checker.declarationsOf(property) : []) {
+                        for (const declaration of property ? property.declarations : []) {
                             if (ts.isMethodDeclaration(declaration) || ts.isAccessor(declaration))
                                 continue;
                             let owner = declaration.parent;
@@ -5015,7 +5783,7 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
                                 owner = owner.parent;
                             if (!owner ||
                                 (!ts.isClassDeclaration(owner) && !ts.isClassExpression(owner)) ||
-                                !isJsSourceFile(owner.getSourceFile()))
+                                !isJsSourceFile(ts.getSourceFileOfNode(owner)))
                                 continue;
                             let fields = lowerer.inheritedJsFieldWrites.get(owner);
                             if (!fields)
@@ -5041,15 +5809,15 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
  * hierarchy identifies the original declarations through aliases as well. */
 export function collectVirtualJsMethods(lowerer, files) {
     const families = [];
-    collectClassMethodMutations(lowerer, files);
+    lowerer.speculativeTypeQueries(() => collectClassMethodMutations(lowerer, files));
     const visit = (node) => {
         if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
-            const accessors = node.members.filter((member) => (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) &&
+            const accessors = node.members.nodes.filter((member) => (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) &&
                 ts.isIdentifier(member.name) &&
-                !member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
-            if (node.heritageClauses?.length &&
+                !member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
+            if (node.heritageClauses?.nodes.length &&
                 accessors.length &&
-                isJsSourceFile(node.getSourceFile())) {
+                isJsSourceFile(ts.getSourceFileOfNode(node))) {
                 const symbol = lowerer.typeOf(node).getSymbol();
                 const instance = symbol ? lowerer.checker.getDeclaredTypeOfSymbol(symbol) : null;
                 const seen = new Set();
@@ -5063,13 +5831,13 @@ export function collectVirtualJsMethods(lowerer, files) {
                             if (!ts.isIdentifier(member.name))
                                 continue;
                             const property = lowerer.checker.getPropertyOfType(base, member.name.text);
-                            for (const declaration of property ? lowerer.checker.declarationsOf(property) : []) {
+                            for (const declaration of property ? property.declarations : []) {
                                 if ((ts.isGetAccessorDeclaration(declaration) ||
                                     ts.isSetAccessorDeclaration(declaration)) &&
-                                    isJsSourceFile(declaration.getSourceFile())) {
+                                    isJsSourceFile(ts.getSourceFileOfNode(declaration))) {
                                     lowerer.checkedVirtualJsAccessors.add(declaration);
                                     lowerer.checkedVirtualJsAccessors.add(member);
-                                    for (const twin of node.members)
+                                    for (const twin of node.members.nodes)
                                         if ((ts.isGetAccessorDeclaration(twin) || ts.isSetAccessorDeclaration(twin)) &&
                                             ts.isIdentifier(twin.name) &&
                                             twin.name.text === member.name.text)
@@ -5083,10 +5851,10 @@ export function collectVirtualJsMethods(lowerer, files) {
                 if (instance)
                     markAccessors(instance);
             }
-            const members = node.members.filter((member) => ts.isMethodDeclaration(member) &&
+            const members = node.members.nodes.filter((member) => ts.isMethodDeclaration(member) &&
                 ts.isIdentifier(member.name) &&
-                !member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
-            if (node.heritageClauses?.length && members.length > 0) {
+                !member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
+            if (node.heritageClauses?.nodes.length && members.length > 0) {
                 const symbol = lowerer.typeOf(node).getSymbol();
                 const instance = symbol ? lowerer.checker.getDeclaredTypeOfSymbol(symbol) : null;
                 const seen = new Set();
@@ -5100,22 +5868,23 @@ export function collectVirtualJsMethods(lowerer, files) {
                             if (!ts.isIdentifier(member.name))
                                 continue;
                             const property = lowerer.checker.getPropertyOfType(base, member.name.text);
-                            for (const declaration of property ? lowerer.checker.declarationsOf(property) : []) {
+                            for (const declaration of property ? property.declarations : []) {
                                 if (ts.isMethodDeclaration(declaration) &&
-                                    isJsSourceFile(declaration.getSourceFile())) {
+                                    isJsSourceFile(ts.getSourceFileOfNode(declaration)) &&
+                                    !checkedJsOverride(lowerer, declaration, member)) {
                                     lowerer.virtualJsMethods.add(declaration);
-                                    if (isJsSourceFile(member.getSourceFile()) &&
-                                        !member.typeParameters &&
+                                    if (isJsSourceFile(ts.getSourceFileOfNode(member)) &&
+                                        !member.typeParameters?.nodes &&
                                         !member.asteriskToken &&
-                                        !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
+                                        !member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
                                         !bodyReadsArguments(member) &&
-                                        member.parameters.every((p) => !p.dotDotDotToken)) {
-                                        lowerer.virtualJsMethodArity.set(declaration, Math.max(lowerer.virtualJsMethodArity.get(declaration) ?? 0, member.parameters.length));
-                                        const checked = !declaration.typeParameters &&
+                                        member.parameters.nodes.every((p) => !p.dotDotDotToken)) {
+                                        lowerer.virtualJsMethodArity.set(declaration, Math.max(lowerer.virtualJsMethodArity.get(declaration) ?? 0, member.parameters.nodes.length));
+                                        const checked = !declaration.typeParameters?.nodes &&
                                             !declaration.asteriskToken &&
-                                            !declaration.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
+                                            !declaration.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
                                             !bodyReadsArguments(declaration) &&
-                                            [...member.parameters, ...declaration.parameters].every((p) => !p.dotDotDotToken);
+                                            [...member.parameters.nodes, ...declaration.parameters.nodes].every((p) => !p.dotDotDotToken);
                                         if (checked) {
                                             lowerer.checkedVirtualJsMethods.add(declaration);
                                             lowerer.checkedVirtualJsMethods.add(member);
@@ -5141,7 +5910,7 @@ export function collectVirtualJsMethods(lowerer, files) {
                 return;
             if (ts.isReturnStatement(node) && node.expression)
                 lowerer.checkedVirtualJsValueReturns.add(member);
-            node.forEachChild(scan);
+            ts.forEachChild(node, scan);
         };
         scan(member);
     }
@@ -5160,6 +5929,14 @@ export function collectVirtualJsMethods(lowerer, files) {
         }
     }
 }
+/** An override whose base and overriding methods are in files TypeScript
+ * checks and document every parameter: TypeScript checks the override
+ * against its base, so both keep their declared signatures, as in
+ * TypeScript classes. */
+function checkedJsOverride(lowerer, base, member) {
+    return [base, member].every((method) => lowerer.checkedJsFile(ts.getSourceFileOfNode(method)) &&
+        method.parameters.nodes.every(documentedParameter));
+}
 /** The receiver's EXACT runtime class, when the expression proves it: a
  * `new C(...)` expression directly, or a const binding initialized with
  * one (the binding can never be reassigned to a subclass instance).
@@ -5182,7 +5959,7 @@ export function exactInstanceClassOf(lowerer, expr) {
     if (!ts.isIdentifier(e))
         return null;
     const symbol = lowerer.resolveValueSymbol(e);
-    const decl = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+    const decl = symbol ? symbol.valueDeclaration : undefined;
     if (!decl ||
         !ts.isVariableDeclaration(decl) ||
         decl.initializer === undefined ||
@@ -5272,19 +6049,39 @@ export function lowerClassGenericMethodCall(lowerer, call, access, recvInfo, fou
             loc,
         }
         : upcastTo(lowerer, receiver, declarer.def.name);
-    const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
-    return {
+    const args = lowerer.completeArgs(call.arguments.nodes, instance.params, loc, call);
+    const result = {
         kind: "call",
         callee: instance.name,
         args: [thisArg, ...args],
         type: instance.returnType,
         loc,
     };
+    // A fluent JavaScript method (every return ends in `this`, jose's claim
+    // setters) answers the receiver: the instance returns the declarer's
+    // class, a used result's checker type is the receiver's subclass.
+    if (result.type.kind === "object" &&
+        !ts.isExpressionStatement(call.parent) &&
+        ts.isMethodDeclaration(info.decl) &&
+        isJsSourceFile(ts.getSourceFileOfNode(info.decl)) &&
+        returnsOnlyThisValue(info.decl)) {
+        return lowerer.maybeNarrow(result, call);
+    }
+    return result;
 }
 /** Wraps a derived-class expression in an upcast when the target base
  * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
 export function upcastTo(lowerer, expr, className) {
     if (expr.type.kind === "object" && expr.type.className !== className) {
+        // A value lowered at an ANCESTOR of the class the site needs (a
+        // fluent `this` result whose lowering kept the method's declaring
+        // class, the receiver of the next call in a chain): the checker
+        // vouches for the subclass, so the bridge is the verified downcast,
+        // never an upcast the validator rejects (an internal error before).
+        if (!lowerer.isSubclassOf(expr.type.className, className) &&
+            lowerer.isSubclassOf(className, expr.type.className)) {
+            return { kind: "downcast", value: expr, type: { kind: "object", className }, loc: expr.loc };
+        }
         return { kind: "upcast", value: expr, type: { kind: "object", className }, loc: expr.loc };
     }
     return expr;
@@ -5302,24 +6099,24 @@ export function upcastTo(lowerer, expr, className) {
  * form with an exact static story under monomorphization (the
  * instantiation adopts the base's ABI; see collectClassShapeInner). */
 function mixinForwardingCtor(lowerer, ctor) {
-    if (ctor.parameters.length !== 1 || !ctor.body)
+    if (ctor.parameters.nodes.length !== 1 || !ctor.body)
         return false;
-    const p = ctor.parameters[0];
+    const p = ctor.parameters.nodes[0];
     if (!p.dotDotDotToken || !ts.isIdentifier(p.name))
         return false;
     const paramName = p.name;
     const paramSym = lowerer.checker.getSymbolAtLocation(paramName);
     if (!paramSym)
         return false;
-    const first = ctor.body.statements[0];
+    const first = ctor.body.statements.nodes[0];
     if (!first || !ts.isExpressionStatement(first) || !ts.isCallExpression(first.expression))
         return false;
     const call = first.expression;
     if (call.expression.kind !== ts.SyntaxKind.SuperKeyword)
         return false;
-    if (call.arguments.length !== 1)
+    if (call.arguments.nodes.length !== 1)
         return false;
-    const a = call.arguments[0];
+    const a = call.arguments.nodes[0];
     if (!ts.isSpreadElement(a) || !ts.isIdentifier(a.expression))
         return false;
     const spreadIdent = a.expression;
@@ -5372,7 +6169,7 @@ export function lowerClassMembers(lowerer, info) {
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
-            if (info.decl && isJsSourceFile(info.decl.getSourceFile())) {
+            if (info.decl && isJsSourceFile(ts.getSourceFileOfNode(info.decl))) {
                 const types = [
                     { kind: "object", className },
                     ...info.ctorParams.map((param) => param.type),
@@ -5483,7 +6280,7 @@ function lowerClassCtorInner(lowerer, info) {
             // The default-param prologue runs FIRST — before field initializers
             // and (in a derived class) before super(): JS evaluates parameter
             // defaults on entry, ahead of everything the body does.
-            const declared = lowerer.declareParams(info.ctor.parameters, info.ctorParams);
+            const declared = lowerer.declareParams(info.ctor.parameters.nodes, info.ctorParams);
             params.push(...declared.params);
             if (info.ctorParams.at(-1)?.mode === "arguments") {
                 const local = lowerer.declareHiddenLocal("%arguments", DYN);
@@ -5499,7 +6296,7 @@ function lowerClassCtorInner(lowerer, info) {
                 body.push(...lowerer.fieldInitStmts(info, thisLocal));
                 body.push(...paramPropInitStmts(lowerer, info, thisLocal));
                 if (info.ctor.body)
-                    body.push(...lowerer.lowerStmts(info.ctor.body.statements));
+                    body.push(...lowerer.lowerStmts(info.ctor.body.statements.nodes));
             }
             else if (info.ctor.body) {
                 body.push(...lowerer.lowerDerivedCtorBody(info, thisLocal));
@@ -5556,7 +6353,7 @@ function lowerClassCtorInner(lowerer, info) {
  * private, static and abstract members are not prototype string keys. */
 function classPrototypeNames(decl) {
     const names = [];
-    for (const member of decl.members) {
+    for (const member of decl.members.nodes) {
         if (!ts.isMethodDeclaration(member) &&
             !ts.isGetAccessorDeclaration(member) &&
             !ts.isSetAccessorDeclaration(member))
@@ -5608,7 +6405,8 @@ export function classMemberNameOf(lowerer, name) {
         if (member === "iterator" ||
             member === "asyncIterator" ||
             member === "dispose" ||
-            member === "asyncDispose") {
+            member === "asyncDispose" ||
+            member === "toPrimitive") {
             return `sym:${member}`;
         }
     }
@@ -5921,6 +6719,77 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
             allowDiagSink: true,
         });
     }
+    // An override converting its declared result into the inherited ABI:
+    // the body lowers as `%C.m$own` under its declared result, and the slot
+    // function forwards to it and converts what it returns.
+    const adapter = info.returnAdapters?.get(mName);
+    if (adapter) {
+        const ownSig = { ...sig, params: adapter.params, ret: adapter.ret };
+        if (adapter.async)
+            ownSig.async = true;
+        const own = lowerClassMethodBody(lowerer, info, fnLike, `%${className}.${mName}$own`, ownSig);
+        if (!own)
+            return null;
+        lowerer.liftedFns.push(own);
+        const loc = locOf(fnLike);
+        const params = [
+            { localId: "this.0", name: "this", type: thisType },
+            ...sig.params.map((p, i) => ({ localId: `p.${i}`, name: `p${i}`, type: p.type })),
+        ];
+        const fnCtx = newFnCtx(false, null, null, sig.ret);
+        lowerer.fnStack.push(fnCtx);
+        try {
+            const call = {
+                kind: "call",
+                callee: own.name,
+                args: params.map((p, i) => {
+                    const ref = { kind: "varRef", localId: p.localId, type: p.type, loc };
+                    // `this` passes through; each inherited argument converts into
+                    // the override's declared parameter (checked where it narrows).
+                    return i === 0 ? ref : lowerer.coerceInto(fnLike.name, ref, adapter.params[i - 1].type);
+                }),
+                type: adapter.ret,
+                loc,
+            };
+            // A void slot discards the override's result after running it. A
+            // toString slot hands on what every ToString consumer of the result
+            // makes of it (`String(err)`, templates): undefined reads
+            // "undefined", as in Node. Other slots check the result into the
+            // inherited type.
+            const result = () => mName === "toString" && sig.ret.kind === "string"
+                ? call.type.kind === "dyn"
+                    ? { kind: "libCall", fn: "dyn.stringConstructor", args: [call], type: STRING, loc }
+                    : lowerer.ensureString(call, fnLike.name)
+                : lowerer.coerceInto(fnLike.name, call, sig.ret);
+            const body = sig.ret.kind === "void"
+                ? [
+                    { kind: "exprStmt", expr: call, loc },
+                    { kind: "return", value: null, loc },
+                ]
+                : [{ kind: "return", value: result(), loc }];
+            return {
+                name: `%${className}.${mName}`,
+                params,
+                returnType: sig.ret,
+                locals: [
+                    ...params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+                    ...lowerer.ctx.locals,
+                ],
+                body,
+                loc,
+            };
+        }
+        finally {
+            lowerer.fnStack.pop();
+        }
+    }
+    return lowerClassMethodBody(lowerer, info, fnLike, `%${className}.${mName}`, sig);
+}
+function lowerClassMethodBody(lowerer, info, fnLike, fnName, sig) {
+    const className = info.def.name;
+    const thisType = { kind: "object", className };
+    if (!fnLike.body)
+        return null;
     const prevClass = lowerer.currentClass;
     lowerer.currentClass = info;
     // ASYNC methods: the module function is an async IrFunction — its
@@ -5949,7 +6818,7 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
         // `this` is declared first, so method parameter DEFAULTS may use it
         // (JS allows this in method defaults; it is param 0 here).
-        const declared = lowerer.declareParams(fnLike.parameters, sig.params);
+        const declared = lowerer.declareParams(fnLike.parameters.nodes, sig.params);
         params.push(...declared.params);
         // A shorter JS override still implements every inherited ABI slot.
         // These tail parameters have no source binding or default prologue.
@@ -5960,10 +6829,10 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
             if (shape.mode === "arguments")
                 fnCtx.argumentsLocal = local;
         }
-        const body = [...declared.prologue, ...lowerer.lowerStmts(fnLike.body.statements)];
+        const body = [...declared.prologue, ...lowerer.lowerStmts(fnLike.body.statements.nodes)];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(fnLike));
         const fn = {
-            name: `%${className}.${mName}`,
+            name: fnName,
             params,
             returnType: bodyReturn,
             locals: lowerer.ctx.locals,
@@ -5993,7 +6862,7 @@ export function lowerStaticMethod(lowerer, info, name) {
     const entry = info.staticMethods?.get(name);
     if (!entry?.member.body)
         return null;
-    const isAsync = entry.member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+    const isAsync = entry.member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
     const isGenerator = entry.member.asteriskToken !== undefined;
     if (isGenerator && (entry.ret.kind !== "generator" || (entry.ret.async === true) !== isAsync)) {
         lowerer.badType(entry.member.name, lowerer.typeOf(entry.member.name));
@@ -6014,13 +6883,13 @@ export function lowerStaticMethod(lowerer, info, name) {
     lowerer.fnStack.push(fnCtx);
     try {
         rejectStaticThis(lowerer, entry.member.body, (keyword) => `'${keyword}' in static methods (it names the RECEIVER class — a dynamic value; reference the class by name instead)`);
-        const declared = lowerer.declareParams(entry.member.parameters, entry.params);
+        const declared = lowerer.declareParams(entry.member.parameters.nodes, entry.params);
         if (entry.params.at(-1)?.mode === "arguments") {
             const local = lowerer.declareHiddenLocal("%arguments", DYN);
             declared.params.push({ localId: local.id, name: "%arguments", type: DYN });
             fnCtx.argumentsLocal = local;
         }
-        const body = [...declared.prologue, ...lowerer.lowerStmts(entry.member.body.statements)];
+        const body = [...declared.prologue, ...lowerer.lowerStmts(entry.member.body.statements.nodes)];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(entry.member));
         const fn = {
             name: `%${info.def.name}.static:${name}`,
@@ -6091,6 +6960,13 @@ export function throwingSetterFn(lowerer, info, prop) {
         loc,
     };
 }
+/** The declared type a refused checked-dynamic class field names in its
+ * diagnostic (`'any'`, `'WeakMap<object, string>'`): `unknown` and
+ * `object` fields store checked-dynamic values, so the refusal is about
+ * whatever else the declaration spells. */
+function dynFieldTypeSpelling(lowerer, node) {
+    return `'${lowerer.checker.typeToString(lowerer.typeOf(node))}'`;
+}
 /** The base a constructor chain actually CALLS into: generic FAMILIES are
  * never constructed (no `%<family>.constructor` exists), so an
  * instantiation's construction-relevant base is the family's own base —
@@ -6134,14 +7010,15 @@ export function fieldInitStmts(lowerer, info, thisLocal) {
                 className: info.def.name,
                 field: f.name,
                 value: dynUndefinedExpr(loc),
+                define: true,
                 loc,
             });
         }
         if (!f.initializer)
             continue;
-        lowerer.stats.statementsTotal++;
-        lowerer.bumpFileStat(locOf(f.initializer).file, "total");
+        lowerer.countStatement(f.initializer, locOf(f.initializer).file);
         const diagsBefore = lowerer.diags.length;
+        const sinkMark = lowerer.diagSinkMark();
         try {
             const value = lowerer.lowerExprExpecting(f.initializer, f.type);
             out.push({
@@ -6150,18 +7027,18 @@ export function fieldInitStmts(lowerer, info, thisLocal) {
                 className: info.def.name,
                 field: f.name,
                 value,
+                define: true,
                 loc: locOf(f.initializer),
             });
         }
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
-            lowerer.stats.statementsFailed++;
-            lowerer.bumpFileStat(locOf(f.initializer).file, "failed");
-            if (isJsSourceFile(f.initializer.getSourceFile()) && lowerer.diagSink === null) {
-                const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, {
-                    kind: "statement",
-                });
+            lowerer.countStatementFailed(f.initializer, locOf(f.initializer).file);
+            if (isJsSourceFile(ts.getSourceFileOfNode(f.initializer))) {
+                const fence = lowerer.diagSink === null
+                    ? lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { kind: "statement" })
+                    : lowerer.capturedRuntimeFence(sinkMark, f.initializer);
                 if (fence)
                     out.push(fence);
             }
@@ -6200,6 +7077,24 @@ function paramPropInitStmts(lowerer, info, thisLocal) {
     }
     return out;
 }
+/** Whether a super() call's value is discarded by its statement: the call
+ * is the expression statement itself, or an operand of a comma chain that
+ * is (`super(m, o), this.code = c;`, as minifiers join statements). The
+ * statement lowering runs each comma operand as its own statement in
+ * source order, so the chain lowers exactly like `super(m, o); this.code =
+ * c;`. Parentheses are transparent to both. */
+function superCallInStatementPosition(call) {
+    let node = call;
+    for (;;) {
+        const parent = node.parent;
+        if (ts.isExpressionStatement(parent))
+            return true;
+        const comma = ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.CommaToken;
+        if (!comma && !ts.isParenthesizedExpression(parent))
+            return false;
+        node = parent;
+    }
+}
 /** Super statements initialize the base and then the derived fields on
  * whichever control-flow path executes. Repeated calls are explicitly
  * refused until native layouts can allocate a second receiver. */
@@ -6212,7 +7107,7 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
     const previousInitialized = context.superInitialized;
     context.superInitialized = initialized;
     context.superCall = (superCall) => {
-        if (!ts.isExpressionStatement(superCall.parent))
+        if (!superCallInStatementPosition(superCall))
             lowerer.unsupported("SC1090", superCall, "super() in an expression position");
         superSeen = true;
         const loc = locOf(superCall);
@@ -6232,11 +7127,11 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
             },
         ];
         if (info.callableBase) {
-            if (superCall.arguments.some(ts.isSpreadElement))
+            if (superCall.arguments.nodes.some(ts.isSpreadElement))
                 lowerer.unsupported("SC1090", superCall, "spreading explicit super arguments into an ordinary constructor");
             const pack = {
                 kind: "dynArrLit",
-                elems: superCall.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                elems: superCall.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                 type: DYN,
                 loc,
             };
@@ -6244,19 +7139,19 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
         }
         else {
             const base = superBaseOf(info);
-            if (base.builtinEmitter && superCall.arguments.length > 0)
+            if (base.builtinEmitter && superCall.arguments.nodes.length > 0)
                 lowerer.unsupported("SC1090", superCall, "EventEmitter constructor options ('captureRejections')");
             if (base.builtinStream) {
-                statements.push(...lowerStreamSuperCall(lowerer, info, base, superCall.arguments, thisLocal, loc, superCall));
+                statements.push(...lowerStreamSuperCall(lowerer, info, base, superCall.arguments.nodes, thisLocal, loc, superCall));
             }
             else {
                 const surplusSpread = forward === undefined &&
                     !base.builtinError &&
                     !base.builtinEmitter &&
                     base.ctorParams.length === 0 &&
-                    superCall.arguments.some(ts.isSpreadElement);
+                    superCall.arguments.nodes.some(ts.isSpreadElement);
                 if (surplusSpread) {
-                    const evaluated = lowerer.completeArgs(superCall.arguments, [{ mode: "dynRest", type: DYN }], loc, superCall);
+                    const evaluated = lowerer.completeArgs(superCall.arguments.nodes, [{ mode: "dynRest", type: DYN }], loc, superCall);
                     for (const value of evaluated)
                         statements.push({ kind: "exprStmt", expr: value, loc });
                 }
@@ -6264,26 +7159,26 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
                     !base.builtinError &&
                     !base.builtinEmitter &&
                     !base.ctorParams.some((param) => param.mode === "rest" || param.mode === "dynRest") &&
-                    !superCall.arguments.some(ts.isSpreadElement) &&
-                    superCall.arguments.length > base.ctorParams.length;
+                    !superCall.arguments.nodes.some(ts.isSpreadElement) &&
+                    superCall.arguments.nodes.length > base.ctorParams.length;
                 let args = surplusSpread
                     ? []
                     : forward !== undefined
                         ? forward
                         : base.builtinError
-                            ? lowerer.errorConstructorArgs(superCall.arguments, loc, superCall)
+                            ? lowerer.errorConstructorArgs(superCall.arguments.nodes, loc, superCall)
                             : base.builtinEmitter
                                 ? []
                                 : lowerer.completeArgs(surplus
-                                    ? superCall.arguments.slice(0, base.ctorParams.length)
-                                    : superCall.arguments, base.ctorParams, loc, superCall);
+                                    ? superCall.arguments.nodes.slice(0, base.ctorParams.length)
+                                    : superCall.arguments.nodes, base.ctorParams, loc, superCall);
                 if (surplus) {
                     args = args.map((arg) => {
                         const local = lowerer.declareHiddenLocal("%superArgument", arg.type);
                         statements.push({ kind: "varDecl", localId: local.id, init: arg, loc });
                         return { kind: "varRef", localId: local.id, type: arg.type, loc };
                     });
-                    for (const argument of superCall.arguments.slice(base.ctorParams.length)) {
+                    for (const argument of superCall.arguments.nodes.slice(base.ctorParams.length)) {
                         statements.push({
                             kind: "exprStmt",
                             expr: lowerer.lowerExpr(argument),
@@ -6323,7 +7218,7 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
         };
     };
     try {
-        const result = lowerer.lowerStmts(info.ctor.body.statements);
+        const result = lowerer.lowerStmts(info.ctor.body.statements.nodes);
         result.push({
             kind: "if",
             cond: {
@@ -6370,7 +7265,6 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
  * `this` (upcast; retained by the varRef read — the callee owns and
  * releases its param per the universal convention). */
 export function superCallStmt(lowerer, info, thisLocal, args, loc) {
-    const base = superBaseOf(info);
     const thisRef = {
         kind: "varRef",
         localId: thisLocal.id,
@@ -6415,6 +7309,8 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
             },
             loc,
         };
+    // A callable base has no class info, so the base is read after that case.
+    const base = superBaseOf(info);
     if (base.builtinError) {
         // super(message) into the runtime-provided Error constructor: stamps
         // name/message on the (already-allocated) object. Receiver + message
@@ -6459,7 +7355,7 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         return lowerStreamSuperCall(lowerer, info, base, [], thisLocal, loc, info.decl ?? info.ctor)[0];
     }
     lowerer.noteSuperConstructorEdge(`%${base.def.name}.constructor`);
-    return {
+    const call = {
         kind: "exprStmt",
         expr: {
             kind: "call",
@@ -6470,6 +7366,7 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         },
         loc,
     };
+    return superIntoResultSlot(lowerer, base, info, call, lowerer.upcastTo({ ...thisRef }, base.def.name), info.ctor ?? info.decl);
 }
 /** `super.method(args)`: the base chain's implementation, called
  * DIRECTLY over this method's own `this` (upcast to the declarer) —
@@ -6500,7 +7397,7 @@ export function lowerSuperMethodCall(lowerer, call, access) {
             const instance = genericCallInstance(lowerer, call, gfound.info);
             const loc = locOf(call);
             const thisRef = { kind: "varRef", localId: thisL.id, type: thisL.type, loc };
-            const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
+            const args = lowerer.completeArgs(call.arguments.nodes, instance.params, loc, call);
             return {
                 kind: "call",
                 callee: instance.name,
@@ -6561,8 +7458,8 @@ export function lowerSuperMethodCall(lowerer, call, access) {
                 kind: "dynCall",
                 callee,
                 receiver: lowerer.coerceToExpected(thisRef, DYN),
-                calleeName: access.getText(),
-                args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                calleeName: ts.getTextOfNode(access),
+                args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                 type: DYN,
                 loc,
             };
@@ -6579,7 +7476,7 @@ export function lowerSuperMethodCall(lowerer, call, access) {
         };
     }
     lowerer.noteEdge(`%${found.declarer.def.name}.${access.name.text}`);
-    const args = lowerer.completeArgs(call.arguments, found.sig.params, loc, call);
+    const args = lowerer.completeArgs(call.arguments.nodes, found.sig.params, loc, call);
     return {
         kind: "call",
         callee: `%${found.declarer.def.name}.${access.name.text}`,
@@ -6696,6 +7593,47 @@ function inheritsBuiltinStreamCtor(lowerer, info) {
     }
     return false;
 }
+/** The run-time form of refuseInheritedBuiltinCtorArgs, for construction
+ * from checked-dynamic code (`new F(options)` with F an untyped value
+ * holding C), whose argument count is known only to the caller: a
+ * runtimeFence located at C, or null when C's constructor takes its
+ * arguments. */
+export function inheritedBuiltinCtorFence(lowerer, info, loc) {
+    let feature = null;
+    if (inheritsBuiltinStreamCtor(lowerer, info))
+        feature = `new ${info.def.name.replace(/^%/, "")} with arguments through an inherited stream constructor (declare a constructor that passes an inline options object to super(...))`;
+    else if (lowerer.inheritsBuiltinEmitterCtor(info))
+        feature = "EventEmitter constructor options ('captureRejections')";
+    if (feature === null)
+        return null;
+    // Located at the class, whose constructor takes no arguments.
+    const at = info.decl !== null ? locOf(info.decl) : loc;
+    const diag = unsupportedDiag("SC1090", at, feature);
+    lowerer.runtimeFences.push(diag);
+    const line = info.decl !== null
+        ? ts.getLineAndCharacterOfPosition(ts.getSourceFileOfNode(info.decl), at.start).line + 1
+        : null;
+    const where = line !== null ? ` [${diag.code} at ${at.file}:${line}]` : "";
+    return { kind: "runtimeFence", code: diag.code, message: `${diag.message}${where}`, loc };
+}
+/** `new C(args)` where C's constructor is the inherited runtime stream or
+ * EventEmitter constructor (a ctor-less chain into the base): that
+ * constructor takes zero arguments here (the options bag fences, like the
+ * super() form), so arguments report at the first one. Applies to direct
+ * construction and to construction through a class value of C. Stream
+ * subclasses come first: their chain roots at the emitter too, but the
+ * message should name the stream story. */
+function refuseInheritedBuiltinCtorArgs(lowerer, info, expr) {
+    const first = expr.arguments?.nodes[0];
+    if (first === undefined)
+        return;
+    if (inheritsBuiltinStreamCtor(lowerer, info)) {
+        lowerer.noLowering(`new ${info.def.name.replace(/^%/, "")} with arguments through an inherited stream constructor`, first, "declare a constructor that passes an inline options object to super(...)");
+    }
+    if (lowerer.inheritsBuiltinEmitterCtor(info)) {
+        lowerer.unsupported("SC1090", first, "EventEmitter constructor options ('captureRejections')");
+    }
+}
 /** Preserve argument evaluation order and option presence through builtin
  * and inherited Error constructors. Checked-dynamic conversion retains
  * Error identity and distinguishes a missing cause from undefined. */
@@ -6804,38 +7742,29 @@ function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
     if (info.localClass)
         lowerer.unsupported("SC1090", expr, "construction through a function-local class's internal name");
     lowerer.noteEdge(`%${info.def.name}.constructor`);
-    // A ctor-less chain into an EventEmitter base inherits `new C()` —
-    // zero arguments (the options bag fences, like the super() form).
-    // Stream subclasses come first: their chain roots at the emitter
-    // too, but the message should name the stream story.
-    if (inheritsBuiltinStreamCtor(lowerer, info) && (expr.arguments ?? []).length > 0) {
-        lowerer.noLowering(`new ${info.def.name.replace(/^%/, "")} with arguments through an inherited stream constructor`, expr.arguments[0], "declare a constructor that passes an inline options object to super(...)");
-    }
-    if (lowerer.inheritsBuiltinEmitterCtor(info) && (expr.arguments ?? []).length > 0) {
-        lowerer.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
-    }
+    refuseInheritedBuiltinCtorArgs(lowerer, info, expr);
     // A ctor-less chain into a builtin error base inherits both arguments;
     // each synthesized constructor forwards the same pair to its base.
     const args = lowerer.inheritsBuiltinErrorCtor(info)
-        ? lowerer.errorConstructorArgs(expr.arguments ?? [], loc, expr)
-        : lowerer.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
+        ? lowerer.errorConstructorArgs(expr.arguments?.nodes ?? [], loc, expr)
+        : lowerer.completeArgs(expr.arguments?.nodes ?? [], info.ctorParams, loc, expr);
     for (let current = info; current; current = current.base) {
         if (current.def.baseValueGlobal)
-            return {
+            return constructedValue(lowerer, info, {
                 kind: "newValue",
                 callee: classValueRef(lowerer, info, expr),
                 args,
                 type: { kind: "object", className: info.def.name },
                 loc,
-            };
+            });
     }
-    return {
+    return constructedValue(lowerer, info, {
         kind: "new",
         className: info.def.name,
         args,
         type: { kind: "object", className: info.def.name },
         loc,
-    };
+    });
 }
 function assignedThisFieldType(lowerer, expr) {
     const parent = expr.parent;
@@ -6848,21 +7777,53 @@ function assignedThisFieldType(lowerer, expr) {
     }
     return lowerer.currentClass?.fields.get(parent.left.name.text) ?? null;
 }
+/** Map, Set and the error classes construct in lowerNew's identifier
+ * branch, which a module member alias of one (`new mod.M()`) also takes. */
+function isCollectionOrErrorClass(ref) {
+    return ref?.kind === "collection" || ref?.kind === "error";
+}
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    // A dependency's deprecated `new Buffer(...)` fallback (containers/bytes.ts).
+    {
+        const buffer = lowerNodeModulesBufferConstruct(lowerer, expr);
+        if (buffer)
+            return buffer;
+    }
+    // new Function(...): Node's EvalError under
+    // --disallow-code-generation-from-strings (code-generation.ts).
+    if (codeGenerationCalleeOf(lowerer, expr.expression) === "Function")
+        return lowerCodeGenerationCall(lowerer, expr, "Function");
+    // `new <temporal>.X(...)`: Node 24 has no such global, so the callee's
+    // root read throws the ReferenceError before any argument evaluates.
+    {
+        const root = ambientUndefVarRootOf(lowerer, expr.expression);
+        if (root !== null && root.text === TEMPORAL_GLOBAL) {
+            const t = ambientUndefReadType(lowerer, expr) ?? contextualUndefReadType(lowerer, expr) ?? F64;
+            return nsUndefRead(lowerer, root.text, expr, t);
+        }
+    }
+    // `new (require("./x").C)()`: the module's %init at the require's
+    // position, then construction through the member as for a binding.
+    if (ts.isPropertyAccessExpression(expr.expression) && !expr.expression.questionDotToken) {
+        const req = inlineNamespaceRequireOf(lowerer, expr.expression.expression);
+        if (req !== null && !lowerer.inlineRequireInitDone.has(req.call)) {
+            return lowerWithInlineRequireInit(lowerer, req, () => lowerNew(lowerer, expr));
+        }
+    }
     const worker = lowerWorkerNew(lowerer, expr);
     if (worker)
         return worker;
     const readlineUi = lowerReadlineUiNew(lowerer, expr);
     if (readlineUi)
         return readlineUi;
-    const channel = lowerMessageChannelNew(lowerer, expr);
+    const channel = lowerMessageChannelNew(lowerer, expr) ?? lowerBroadcastChannelNew(lowerer, expr);
     if (channel)
         return channel;
     let intlConstructor = expr.expression;
     if (ts.isIdentifier(intlConstructor)) {
         const symbol = lowerer.resolveValueSymbol(intlConstructor);
-        const declaration = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+        const declaration = symbol ? symbol.valueDeclaration : undefined;
         if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer)
             intlConstructor = declaration.initializer;
     }
@@ -6871,6 +7832,9 @@ export function lowerNew(lowerer, expr) {
         : null;
     if (intl && intl !== "Segmenter")
         lowerer.noLowering(`new Intl.${intl}`, expr, undefined, lowerer.checker.getSymbolAtLocation(expr.expression));
+    const valueReturning = lowerValueReturningConstructorNew(lowerer, expr);
+    if (valueReturning)
+        return valueReturning;
     const instanceConstructor = lowerInstanceConstructorNew(lowerer, expr);
     if (instanceConstructor)
         return instanceConstructor;
@@ -6880,11 +7844,9 @@ export function lowerNew(lowerer, expr) {
     if (ts.isIdentifier(expr.expression)) {
         const symbol = lowerer.resolveValueSymbol(expr.expression);
         const declaration = symbol &&
-            lowerer.checker
-                .declarationsOf(symbol)
-                .find((node) => ts.isFunctionDeclaration(node) && node.body !== undefined);
+            symbol.declarations.find((node) => ts.isFunctionDeclaration(node) && node.body !== undefined);
         if (declaration && ts.isFunctionDeclaration(declaration) && declaration.body) {
-            const last = declaration.body.statements.at(-1);
+            const last = declaration.body.statements.nodes.at(-1);
             if (last &&
                 ts.isReturnStatement(last) &&
                 last.expression &&
@@ -6921,7 +7883,7 @@ export function lowerNew(lowerer, expr) {
     if (ts.isPropertyAccessExpression(expr.expression) &&
         expr.expression.name.text === "Segmenter" &&
         lowerer.isStdlibGlobal(expr.expression.expression, "Intl")) {
-        const args = expr.arguments ?? [];
+        const args = expr.arguments?.nodes ?? [];
         const undefinedArg = (arg) => (lowerer.typeOf(arg).flags & ts.TypeFlags.Undefined) !== 0;
         if (args.length > 2 || (args[0] && !undefinedArg(args[0]))) {
             lowerer.noLowering("Intl.Segmenter locale negotiation", expr, "omit the locale or pass undefined for default Unicode grapheme segmentation");
@@ -6930,7 +7892,7 @@ export function lowerNew(lowerer, expr) {
         if (options &&
             !undefinedArg(options) &&
             !(ts.isObjectLiteralExpression(options) &&
-                options.properties.every((property) => ts.isPropertyAssignment(property) &&
+                options.properties.nodes.every((property) => ts.isPropertyAssignment(property) &&
                     (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
                     property.name.text === "granularity" &&
                     ts.isStringLiteral(property.initializer) &&
@@ -6970,8 +7932,8 @@ export function lowerNew(lowerer, expr) {
             : memberSym;
         const emitterInfo = lowerer.builtinEmitterInfoOf(resolved);
         if (emitterInfo) {
-            if ((expr.arguments ?? []).length > 0) {
-                lowerer.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
+            if ((expr.arguments?.nodes ?? []).length > 0) {
+                lowerer.unsupported("SC1090", expr.arguments.nodes[0], "EventEmitter constructor options ('captureRejections')");
             }
             return {
                 kind: "libCall",
@@ -6992,8 +7954,8 @@ export function lowerNew(lowerer, expr) {
         // `new zlib.Gzip(options?)` — the zlib stream classes.
         const zlibModeNs = zlibStreamModeOf(lowerer, resolved);
         if (zlibModeNs !== null) {
-            const what = `new zlib.${expr.expression.name.text}`;
-            return lowerZlibStreamNew(lowerer, expr.arguments ?? [], zlibModeNs, what, expr, loc);
+            const what = `new zlib.${zlibClassName(zlibModeNs)}`;
+            return lowerZlibStreamNew(lowerer, expr.arguments?.nodes ?? [], zlibModeNs, what, expr, loc);
         }
         // `new N.C(...)` / `new a.Point(...)` — construction through a
         // USER namespace qualifier (import= alias chains included): the
@@ -7040,7 +8002,7 @@ export function lowerNew(lowerer, expr) {
         // member-export symbol's; the class collects on demand (a body
         // lowering ahead of the assignment statement).
         if (!expr.expression.questionDotToken &&
-            ((isCjsJsFile(expr.getSourceFile(), lowerer.program) &&
+            ((isCjsJsFile(ts.getSourceFileOfNode(expr), lowerer.program) &&
                 (isModuleExportsAccess(expr.expression.expression) ||
                     (ts.isIdentifier(expr.expression.expression) &&
                         expr.expression.expression.text === "exports" &&
@@ -7055,7 +8017,7 @@ export function lowerNew(lowerer, expr) {
                 memberSym,
                 resolved,
                 lowerer.resolveValueSymbol(expr.expression.name) ?? undefined,
-                lowerer.cjsModuleExportSymbol(expr.getSourceFile(), expr.expression.name.text),
+                lowerer.cjsModuleExportSymbol(ts.getSourceFileOfNode(expr), expr.expression.name.text),
             ];
             const exportSym = candidates.find((s) => s !== undefined);
             const g = candidates
@@ -7075,14 +8037,14 @@ export function lowerNew(lowerer, expr) {
                     };
                     below(info);
                     const callee = { kind: "varRef", localId: g.id, type: g.type, loc };
-                    const args = lowerer.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
-                    return {
+                    const args = lowerer.completeArgs(expr.arguments?.nodes ?? [], info.ctorParams, loc, expr);
+                    return constructedFromValue(lowerer, info, {
                         kind: "newValue",
                         callee,
                         args,
                         type: { kind: "object", className: info.def.name },
                         loc,
-                    };
+                    }, expr);
                 }
             }
         }
@@ -7106,7 +8068,10 @@ export function lowerNew(lowerer, expr) {
     if (ts.isIdentifier(expr.expression) ||
         (ts.isPropertyAccessExpression(expr.expression) &&
             ts.isIdentifier(expr.expression.name) &&
-            lowerer.isStdlibGlobal(expr.expression.expression, "globalThis"))) {
+            (lowerer.isStdlibGlobal(expr.expression.expression, "globalThis") ||
+                // `new mod.M()` over an exported `const M = Map` or `const E =
+                // TypeError`
+                isCollectionOrErrorClass(builtinClassRefOf(lowerer, expr.expression))))) {
         // `import C = N.C; new C()` — the alias's own source-order guards
         // (a no-op for every non-import= binding).
         if (ts.isIdentifier(expr.expression))
@@ -7114,7 +8079,7 @@ export function lowerNew(lowerer, expr) {
         const identifier = ts.isIdentifier(expr.expression) ? expr.expression : expr.expression.name;
         const symbol = ts.isIdentifier(identifier) ? lowerer.resolveValueSymbol(identifier) : null;
         if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Array")) {
-            return lowerArrayConstructor(lowerer, expr, expr.arguments ?? []);
+            return lowerArrayConstructor(lowerer, expr, expr.arguments?.nodes ?? []);
         }
         if (isNativeProxyInitializer(lowerer, expr))
             return lowerNativeProxy(lowerer, expr);
@@ -7130,7 +8095,7 @@ export function lowerNew(lowerer, expr) {
         // `cause` own-property record) / "Error" for absent, and the legacy
         // numeric code from the name table.
         if (errInfo && errInfo.def.name === "%DOMException") {
-            const args = expr.arguments ?? [];
+            const args = expr.arguments?.nodes ?? [];
             if (args.length > 2) {
                 lowerer.noLowering(`new DOMException with ${args.length} arguments`, expr);
             }
@@ -7163,7 +8128,7 @@ export function lowerNew(lowerer, expr) {
         if (errInfo && errInfo.def.name === "%AssertionError") {
             // new AssertionError(options): Node validates the options object and
             // generates the message from operator, actual and expected.
-            const args = expr.arguments ?? [];
+            const args = expr.arguments?.nodes ?? [];
             if (args.length > 1 || args.some(ts.isSpreadElement)) {
                 lowerer.noLowering(`new AssertionError with this argument list`, expr);
             }
@@ -7176,7 +8141,7 @@ export function lowerNew(lowerer, expr) {
             };
         }
         if (errInfo && errInfo.def.name === "%SuppressedError") {
-            const args = expr.arguments ?? [];
+            const args = expr.arguments?.nodes ?? [];
             if (args.length > 3 || args.some(ts.isSpreadElement)) {
                 lowerer.noLowering(`new SuppressedError with this argument list`, expr);
             }
@@ -7189,7 +8154,7 @@ export function lowerNew(lowerer, expr) {
             };
         }
         if (errInfo && errInfo.def.name === "%AggregateError") {
-            const args = expr.arguments ?? [];
+            const args = expr.arguments?.nodes ?? [];
             if (args.length > 3 || args.some(ts.isSpreadElement)) {
                 lowerer.noLowering(`new AggregateError with this argument list`, expr);
             }
@@ -7203,7 +8168,7 @@ export function lowerNew(lowerer, expr) {
             };
         }
         if (errInfo) {
-            const args = lowerer.errorConstructorArgs(expr.arguments ?? [], loc, expr);
+            const args = lowerer.errorConstructorArgs(expr.arguments?.nodes ?? [], loc, expr);
             return {
                 kind: "libCall",
                 fn: "error.newOptions",
@@ -7217,8 +8182,8 @@ export function lowerNew(lowerer, expr) {
         // (@types/node's captureRejections) has no lowering.
         const emitterInfo = lowerer.builtinEmitterInfoOf(symbol);
         if (emitterInfo) {
-            if ((expr.arguments ?? []).length > 0) {
-                lowerer.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
+            if ((expr.arguments?.nodes ?? []).length > 0) {
+                lowerer.unsupported("SC1090", expr.arguments.nodes[0], "EventEmitter constructor options ('captureRejections')");
             }
             return {
                 kind: "libCall",
@@ -7238,8 +8203,8 @@ export function lowerNew(lowerer, expr) {
             return lowerStreamNew(lowerer, expr, streamInfo);
         const zlibMode = zlibStreamModeOf(lowerer, symbol);
         if (zlibMode !== null) {
-            const what = `new zlib.${symbol.name}`;
-            return lowerZlibStreamNew(lowerer, expr.arguments ?? [], zlibMode, what, expr, loc);
+            const what = `new zlib.${zlibClassName(zlibMode)}`;
+            return lowerZlibStreamNew(lowerer, expr.arguments?.nodes ?? [], zlibMode, what, expr, loc);
         }
         // `new URL(input)`: the WHATWG URL class (stdlib/@types provenance —
         // a user's own `class URL` resolves through classBySymbol below).
@@ -7248,8 +8213,8 @@ export function lowerNew(lowerer, expr) {
         // libregexp engine the literals ride. The pattern compiles EAGERLY,
         // so bad input throws Node's catchable SyntaxError at construction.
         // Checked arguments retain native regexes and perform runtime coercion.
-        if (symbol && symbol.name === "RegExp" && lowerer.isStdlibSymbol(symbol)) {
-            const args = expr.arguments ?? [];
+        if (symbol && ts.symbolName(symbol) === "RegExp" && lowerer.isStdlibSymbol(symbol)) {
+            const args = expr.arguments?.nodes ?? [];
             if (args.length > 2) {
                 lowerer.noLowering(`new RegExp with ${args.length} arguments`, expr);
             }
@@ -7297,16 +8262,10 @@ export function lowerNew(lowerer, expr) {
             };
             const pattern = strArg(args[0], "pattern");
             const flags = strArg(args[1], "flags argument");
-            // Node accepts the 'd' and 'v' flags the engine does not have; a
-            // literal flags string refuses here like the literal regex form.
-            if (flags.kind === "strLit" && args[1] !== undefined) {
-                for (const f of ["d", "v"]) {
-                    if (flags.value.includes(f)) {
-                        lowerer.unsupported("SC1120", args[1], f === "d"
-                            ? "the regex 'd' flag (match indices)"
-                            : "the regex 'v' flag (unicode sets)");
-                    }
-                }
+            // Node accepts the 'd' flag the engine does not have; a literal
+            // flags string refuses here like the literal regex form.
+            if (flags.kind === "strLit" && args[1] !== undefined && flags.value.includes("d")) {
+                lowerer.unsupported("SC1120", args[1], "the regex 'd' flag (match indices)");
             }
             return {
                 kind: "libCall",
@@ -7316,27 +8275,64 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
-        if (symbol && symbol.name === "URL" && lowerer.isStdlibSymbol(symbol)) {
+        if (symbol && ts.symbolName(symbol) === "URL" && lowerer.isStdlibSymbol(symbol)) {
             return lowerUrlNew(lowerer, expr);
         }
         // `new URLSearchParams(init?)`: the WHATWG list (stdlib provenance —
         // see lowerSearchParamsNew for the lowered init shapes).
-        if (symbol && symbol.name === "URLSearchParams" && lowerer.isStdlibSymbol(symbol)) {
+        if (symbol && ts.symbolName(symbol) === "URLSearchParams" && lowerer.isStdlibSymbol(symbol)) {
             return lowerSearchParamsNew(lowerer, expr, loc);
         }
         // Date's read-only value slice: store the constructor's TimeClip'd
         // epoch milliseconds as the scalar date kind. That is sufficient
         // for every getter and toISOString; identity and setters stay
         // fenced, so copying the scalar cannot create an observable lie.
-        if (symbol && symbol.name === "Date" && lowerer.isStdlibSymbol(symbol)) {
-            const args = expr.arguments ?? [];
-            if (args.some(ts.isSpreadElement) || args.length > 1) {
-                lowerer.noLowering(`new Date with ${args.length} arguments`, expr, "new Date(), new Date(milliseconds), and new Date(dateString) are supported; the local-time year/month field constructor has no lowering", symbol);
+        if (symbol && ts.symbolName(symbol) === "Date" && lowerer.isStdlibSymbol(symbol)) {
+            const args = expr.arguments?.nodes ?? [];
+            if (args.some(ts.isSpreadElement)) {
+                lowerer.noLowering(`new Date with spread arguments`, expr, "new Date(), new Date(milliseconds), new Date(dateString), and new Date(year, monthIndex, ...) with listed arguments are supported", symbol);
+            }
+            // new Date(year, monthIndex[, date[, hours[, minutes[, seconds[, ms]]]]]):
+            // local-time fields, converted to UTC in the host zone at run time.
+            // JavaScript callers pass their arguments to the runtime's ToNumber
+            // (in order, exactly the constructor's coercions); typed callers
+            // pass numbers, completed with the spec's defaults (date 1, time
+            // parts 0) for the seven-f64 ABI.
+            if (args.length > 1) {
+                if (isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+                    return {
+                        kind: "libCall",
+                        fn: "date.nativeNewFields",
+                        args: [
+                            {
+                                kind: "dynArrLit",
+                                elems: args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                                type: DYN,
+                                loc,
+                            },
+                        ],
+                        type: DYN,
+                        loc,
+                    };
+                }
+                if (args.length > 7) {
+                    lowerer.noLowering(`new Date with ${args.length} arguments`, expr, undefined, symbol);
+                }
+                const defaults = [0, 0, 1, 0, 0, 0, 0];
+                const fields = [];
+                for (let i = 0; i < 7; i++) {
+                    const arg = args[i];
+                    fields.push(arg !== undefined
+                        ? lowerer.lowerExprExpecting(arg, F64)
+                        : { kind: "numLit", value: defaults[i], type: F64, loc });
+                }
+                return { kind: "libCall", fn: "date.newLocal", args: fields, type: DATE_T, loc };
             }
-            if (isJsSourceFile(expr.getSourceFile())) {
+            if (isJsSourceFile(ts.getSourceFileOfNode(expr))) {
                 return {
                     kind: "libCall",
-                    fn: "date.nativeNew",
+                    // One argument: a string parses with the full date parser.
+                    fn: args.length === 1 ? "date.nativeNewValue" : "date.nativeNew",
                     args: [
                         {
                             kind: "dynArrLit",
@@ -7365,34 +8361,52 @@ export function lowerNew(lowerer, expr) {
             lowerer.noLowering(`new Date of '${lowerer.fmt(arg.type)}' values`, args[0], "pass milliseconds, a date string, or another Date value", symbol);
         }
         // `new StringDecoder(encoding?)` (node:string_decoder): the decoder
-        // is a two-field record — the CANONICAL encoding name (aliases fold
-        // at compile time, exactly what `.encoding` answers in Node) and
-        // the packed-f64 pending state starting at 0 (nothing buffered).
-        // The encoding must be a literal (Node's alias set); omitted means
-        // utf8, Node's default.
-        if (symbol && symbol.name === "StringDecoder" && lowerer.isStdlibSymbol(symbol)) {
-            const args = expr.arguments ?? [];
+        // is a two-field record — the CANONICAL encoding name (exactly what
+        // `.encoding` answers in Node) and the packed-f64 pending state
+        // starting at 0 (nothing buffered). A literal Buffer encoding folds
+        // its alias at compile time; any other encoding argument is
+        // normalized at run time (Node's normalizeEncoding, which throws
+        // ERR_UNKNOWN_ENCODING for an unknown name). Omitted means utf8,
+        // Node's default.
+        if (symbol && ts.symbolName(symbol) === "StringDecoder" && lowerer.isStdlibSymbol(symbol)) {
+            const args = expr.arguments?.nodes ?? [];
             if (args.length > 1) {
                 lowerer.noLowering("new StringDecoder with 2 arguments", expr, undefined, symbol);
             }
-            const encName = args.length === 1 ? bufEncoding(lowerer, "new StringDecoder", args[0]) : "utf8";
+            const encNode = args[0];
+            const encT = encNode ? lowerer.typeOf(encNode) : undefined;
+            const encName = !encNode
+                ? "utf8"
+                : encT.isStringLiteralType()
+                    ? knownBufEncoding(encT.value)
+                    : undefined;
+            const encoding = encName !== undefined
+                ? { kind: "strLit", value: encName, type: STRING, loc }
+                : {
+                    kind: "libCall",
+                    fn: "strdec.encoding",
+                    args: [lowerer.lowerExprExpecting(encNode, DYN)],
+                    type: STRING,
+                    loc,
+                };
             const decT = lowerer.mapTypeOf(lowerer.typeOf(expr));
             if (decT?.kind !== "record")
                 lowerer.badType(expr, lowerer.typeOf(expr));
             return {
                 kind: "recordLit",
                 fields: [
-                    { name: "%enc", value: { kind: "strLit", value: encName, type: STRING, loc } },
+                    { name: "%enc", value: encoding },
                     { name: "%pending", value: { kind: "numLit", value: 0, type: F64, loc } },
                 ],
                 type: decT,
                 loc,
             };
         }
+        const codec = symbol ? ts.symbolName(symbol) : undefined;
         if (symbol &&
-            (symbol.name === "TextDecoder" || symbol.name === "TextEncoder") &&
+            (codec === "TextDecoder" || codec === "TextEncoder") &&
             lowerer.isStdlibSymbol(symbol)) {
-            return lowerTextCodecNew(lowerer, expr, symbol.name);
+            return lowerTextCodecNew(lowerer, expr, codec);
         }
         // `new Uint8Array(...)` / `new Uint32Array(...)` / `new
         // Float32Array(...)` / `new Float64Array(...)`: the typed-array
@@ -7426,25 +8440,26 @@ export function lowerNew(lowerer, expr) {
         // types get their half named specifically instead of the component
         // fence (SC2009, which names Map slots at value positions elsewhere).
         // Both Array() and new Array() share the elements/count lowering.
-        if (symbol?.name === "Object" && lowerer.isStdlibSymbol(symbol)) {
-            const object = lowerObjectConstructor(lowerer, expr.arguments ?? [], loc);
+        if (symbol !== null && ts.symbolName(symbol) === "Object" && lowerer.isStdlibSymbol(symbol)) {
+            const object = lowerObjectConstructor(lowerer, expr.arguments?.nodes ?? [], loc);
             if (object)
                 return object;
         }
-        if (symbol?.name === "Array" && lowerer.isStdlibSymbol(symbol)) {
-            return lowerArrayConstructor(lowerer, expr, expr.arguments ?? []);
+        if (symbol !== null && ts.symbolName(symbol) === "Array" && lowerer.isStdlibSymbol(symbol)) {
+            return lowerArrayConstructor(lowerer, expr, expr.arguments?.nodes ?? []);
         }
-        if (symbol?.name === "Map" && lowerer.isStdlibSymbol(symbol)) {
-            const seedArg = (expr.arguments?.length ?? 0) === 1 ? expr.arguments[0] : null;
+        // A const alias (`const M = Map`) constructs the same Map.
+        if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Map")) {
+            const seedArg = (expr.arguments?.nodes.length ?? 0) === 1 ? expr.arguments.nodes[0] : null;
             const isPairLit = (el) => ts.isArrayLiteralExpression(el) &&
-                el.elements.length === 2 &&
-                !el.elements.some(ts.isSpreadElement);
-            const entriesLit = seedArg && ts.isArrayLiteralExpression(seedArg) && seedArg.elements.every(isPairLit)
-                ? seedArg.elements.filter(isPairLit)
+                el.elements.nodes.length === 2 &&
+                !el.elements.nodes.some(ts.isSpreadElement);
+            const entriesLit = seedArg && ts.isArrayLiteralExpression(seedArg) && seedArg.elements.nodes.every(isPairLit)
+                ? seedArg.elements.nodes.filter(isPairLit)
                 : null;
             let tsType = lowerer.typeOf(expr);
             let mapped = lowerer.mapTypeOf(tsType);
-            if (mapped === null && isJsSourceFile(expr.getSourceFile()))
+            if (mapped === null && isJsSourceFile(ts.getSourceFileOfNode(expr)))
                 mapped = lowerer.irTypeOf(expr);
             const fieldType = assignedThisFieldType(lowerer, expr);
             if (mapped?.kind !== "map" && fieldType?.kind === "map")
@@ -7459,8 +8474,8 @@ export function lowerNew(lowerer, expr) {
                 parent = parent.parent;
             // `satisfies` checks a view but retains the expression's own type.
             const contextualSeed = !ts.isSatisfiesExpression(parent) &&
-                (expr.typeArguments?.length ?? 0) === 0 &&
-                (entriesLit !== null || (expr.arguments?.length ?? 0) === 0);
+                (expr.typeArguments?.nodes.length ?? 0) === 0 &&
+                (entriesLit !== null || (expr.arguments?.nodes.length ?? 0) === 0);
             // JavaScript's `new Map()` has no type-argument syntax: the no-arg
             // constructor overload pins Map<any, any> whatever the JSDoc says
             // (`@type` on the declaration types the VARIABLE, not this
@@ -7480,7 +8495,7 @@ export function lowerNew(lowerer, expr) {
                 if (seeded)
                     return seeded;
             }
-            if ((expr.arguments?.length ?? 0) > 0 && !entriesLit) {
+            if ((expr.arguments?.nodes.length ?? 0) > 0 && !entriesLit) {
                 lowerer.noLowering("new Map(entries)", expr, "supported seeds: an array literal of [key, value] pair literals, or a " +
                     "[K, V][]-typed tuple-array value, a matching collection or collection iterator, or null/undefined");
             }
@@ -7488,10 +8503,10 @@ export function lowerNew(lowerer, expr) {
                 if (!entriesLit)
                     return { kind: "mapNew", type: mapped, loc };
                 const seed = entriesLit.map((pair) => ({
-                    key: lowerer.lowerCollectionKey(pair.elements[0], mapped.key),
+                    key: lowerer.lowerCollectionKey(pair.elements.nodes[0], mapped.key),
                     value: mapped.value.kind === "dyn"
-                        ? lowerer.lowerCollectionKey(pair.elements[1], mapped.value)
-                        : lowerer.lowerExprExpecting(pair.elements[1], mapped.value),
+                        ? lowerer.lowerCollectionKey(pair.elements.nodes[1], mapped.value)
+                        : lowerer.lowerExprExpecting(pair.elements.nodes[1], mapped.value),
                 }));
                 return { kind: "mapNew", seed, type: mapped, loc };
             }
@@ -7504,8 +8519,8 @@ export function lowerNew(lowerer, expr) {
             // config-cache shape: module init constructs the caches
             // unconditionally; the format path never touches them. TypeScript
             // keeps the compile fence.
-            if (isJsSourceFile(expr.getSourceFile()) &&
-                (expr.arguments?.length ?? 0) === 0 &&
+            if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+                (expr.arguments?.nodes.length ?? 0) === 0 &&
                 targs.length > 0 &&
                 targs.every((t) => (t.flags & ts.TypeFlags.Any) !== 0)) {
                 return { kind: "dynObjLit", type: DYN, loc };
@@ -7519,21 +8534,22 @@ export function lowerNew(lowerer, expr) {
             }
             if (targs[1]) {
                 lowerer.unsupported("SC1090", expr, `Map values of type '${lowerer.checker.typeToString(targs[1])}' ` +
-                    `(Map values must be number, string, boolean, records, class instances, ` +
+                    `(Map values must be number, string, boolean, records, class instances, functions, ` +
                     `typed arrays, arrays, promises, Maps, Sets, or supported unions and checked values)`);
             }
             lowerer.badType(expr, tsType);
         }
         // Weak containers share checked native key identities and lifetime hooks.
-        if ((symbol?.name === "WeakMap" || symbol?.name === "WeakSet") &&
+        if (((symbol !== null && ts.symbolName(symbol) === "WeakMap") ||
+            (symbol !== null && ts.symbolName(symbol) === "WeakSet")) &&
             lowerer.isStdlibSymbol(symbol)) {
-            const args = expr.arguments ?? [];
+            const args = expr.arguments?.nodes ?? [];
             if (args.length > 1 || args.some(ts.isSpreadElement)) {
-                lowerer.unsupported("SC1090", expr, `${symbol.name} construction with surplus or spread arguments`);
+                lowerer.unsupported("SC1090", expr, `${ts.symbolName(symbol)} construction with surplus or spread arguments`);
             }
             return {
                 kind: "libCall",
-                fn: symbol.name === "WeakMap" ? "weakMap.new" : "weakSet.new",
+                fn: ts.symbolName(symbol) === "WeakMap" ? "weakMap.new" : "weakSet.new",
                 args: [args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc)],
                 type: DYN,
                 loc,
@@ -7541,27 +8557,27 @@ export function lowerNew(lowerer, expr) {
         }
         // `new Set<T>()`: construct + bulk add from supported values,
         // including live collection cursors. Duplicates collapse in insertion order.
-        if (symbol?.name === "Set" && lowerer.isStdlibSymbol(symbol)) {
+        if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Set")) {
             const tsType = lowerer.typeOf(expr);
             let mapped = lowerer.mapTypeOf(tsType);
             const fieldType = assignedThisFieldType(lowerer, expr);
             if (mapped?.kind !== "set" && fieldType?.kind === "set")
                 mapped = fieldType;
-            if (mapped?.kind === "set" && (expr.arguments?.length ?? 0) === 1) {
-                const seeded = lowerSetSeedNew(lowerer, expr.arguments[0], mapped);
+            if (mapped?.kind === "set" && (expr.arguments?.nodes.length ?? 0) === 1) {
+                const seeded = lowerSetSeedNew(lowerer, expr.arguments.nodes[0], mapped);
                 if (seeded)
                     return seeded;
             }
             if (!mapped &&
-                isJsSourceFile(expr.getSourceFile()) &&
-                (expr.arguments?.length ?? 0) <= 1 &&
-                !expr.arguments?.some(ts.isSpreadElement)) {
+                isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+                (expr.arguments?.nodes.length ?? 0) <= 1 &&
+                !expr.arguments?.nodes.some(ts.isSpreadElement)) {
                 return {
                     kind: "libCall",
                     fn: "dyn.nativeSetNew",
                     args: [
-                        expr.arguments?.[0]
-                            ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
+                        expr.arguments?.nodes[0]
+                            ? lowerer.lowerExprExpecting(expr.arguments.nodes[0], DYN)
                             : dynUndefinedExpr(loc),
                     ],
                     type: DYN,
@@ -7574,12 +8590,12 @@ export function lowerNew(lowerer, expr) {
             // (interned strings — see the JS token stance in lower-exprs), so
             // the honest construction is a Set of those scalars.
             if (!mapped &&
-                isJsSourceFile(expr.getSourceFile()) &&
-                (expr.arguments?.length ?? 0) === 1 &&
-                ts.isArrayLiteralExpression(expr.arguments[0]) &&
-                !expr.arguments[0].elements.some(ts.isSpreadElement)) {
-                const lit = expr.arguments[0];
-                const elems = lit.elements.map((el) => lowerer.lowerExpr(el));
+                isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+                (expr.arguments?.nodes.length ?? 0) === 1 &&
+                ts.isArrayLiteralExpression(expr.arguments.nodes[0]) &&
+                !expr.arguments.nodes[0].elements.nodes.some(ts.isSpreadElement)) {
+                const lit = expr.arguments.nodes[0];
+                const elems = lit.elements.nodes.map((el) => lowerer.lowerExpr(el));
                 const first = elems[0];
                 if (first !== undefined &&
                     (first.type.kind === "string" || first.type.kind === "f64") &&
@@ -7589,7 +8605,7 @@ export function lowerNew(lowerer, expr) {
                     return { kind: "setNew", seed, type: setT, loc };
                 }
             }
-            if ((expr.arguments?.length ?? 0) > 0) {
+            if ((expr.arguments?.nodes.length ?? 0) > 0) {
                 lowerer.noLowering("new Set(values)", expr, "construct the Set empty and add() each value — only nullish values or a matching Set, collection iterator, string, array, or fixed tuple of " +
                     "supported key values seeds a Set");
             }
@@ -7605,18 +8621,20 @@ export function lowerNew(lowerer, expr) {
         // `new AsyncLocalStorage()` (node:async_hooks): a fresh store id —
         // an f64 handle (type-mapper.ts), the Channel story. Construction options
         // ({ defaultValue, name }) have no lowering yet.
-        if (symbol?.name === "AsyncLocalStorage" && lowerer.isStdlibSymbol(symbol)) {
-            if ((expr.arguments?.length ?? 0) > 0) {
+        if (symbol !== null &&
+            ts.symbolName(symbol) === "AsyncLocalStorage" &&
+            lowerer.isStdlibSymbol(symbol)) {
+            if ((expr.arguments?.nodes.length ?? 0) > 0) {
                 lowerer.noLowering("new AsyncLocalStorage(options)", expr, "the zero-argument constructor is the supported form (defaultValue/name options have no lowering yet)");
             }
             return { kind: "libCall", fn: "als.new", args: [], type: F64, loc };
         }
         // `new Promise<T>((resolve) => ...)`: the ambient Promise constructor.
-        if (symbol?.name === "Promise" && lowerer.isStdlibSymbol(symbol)) {
+        if (symbol !== null && ts.symbolName(symbol) === "Promise" && lowerer.isStdlibSymbol(symbol)) {
             const type = lowerer.irTypeOf(expr);
             if (type.kind !== "promise")
                 lowerer.badType(expr, lowerer.typeOf(expr));
-            const args = expr.arguments ?? [];
+            const args = expr.arguments?.nodes ?? [];
             if (args.length !== 1) {
                 lowerer.unsupported("SC1090", expr, "Promise construction without an executor");
             }
@@ -7628,8 +8646,9 @@ export function lowerNew(lowerer, expr) {
                 const a0 = args[0];
                 if (ts.isIdentifier(a0) && a0.text === "setImmediate") {
                     const sym = lowerer.checker.getSymbolAtLocation(a0);
-                    const decls = sym ? lowerer.checker.declarationsOf(sym) : [];
-                    if (decls.length > 0 && decls.every((d) => lowerer.isStdlibFile(d.getSourceFile()))) {
+                    const decls = sym ? sym.declarations : [];
+                    if (decls.length > 0 &&
+                        decls.every((d) => lowerer.isStdlibFile(ts.getSourceFileOfNode(d)))) {
                         // The settled value is the undefined dyn value — the result
                         // is promise<dyn> whatever T the checker inferred for the
                         // unusual executor (Promise<unknown> in the suite's shape).
@@ -7650,7 +8669,10 @@ export function lowerNew(lowerer, expr) {
             // catch-side instanceof and the uncaught printer working). First
             // settle wins, exactly JS: reject-after-resolve and double-reject
             // are no-ops, and an executor throw after any settle is swallowed.
-            const executor = lowerer.lowerExpr(args[0]);
+            let executor = lowerer.lowerExpr(args[0]);
+            if (executor.type.kind !== "func")
+                lowerer.badType(args[0], lowerer.typeOf(args[0]));
+            executor = adaptPromiseExecutor(lowerer, executor, type.inner, loc) ?? executor;
             if (executor.type.kind !== "func")
                 lowerer.badType(args[0], lowerer.typeOf(args[0]));
             if (executor.type.params.length > 1) {
@@ -7682,11 +8704,11 @@ export function lowerNew(lowerer, expr) {
             // Every other new Buffer form keeps the fence below — the
             // constructing forms would owe the deprecation warning.
             if (expr.expression.text === "Buffer" &&
-                expr.arguments?.length === 2 &&
-                !expr.arguments.some(ts.isSpreadElement) &&
-                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[0]))?.kind !== "string" &&
-                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]))?.kind === "string") {
-                const first = lowerer.lowerExpr(expr.arguments[0]);
+                expr.arguments?.nodes.length === 2 &&
+                !expr.arguments.nodes.some(ts.isSpreadElement) &&
+                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[0]))?.kind !== "string" &&
+                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[1]))?.kind === "string") {
+                const first = lowerer.lowerExpr(expr.arguments.nodes[0]);
                 if (first.kind === "unitLit" ||
                     first.type.kind === "dyn" ||
                     lowerer.dynConvertible(first.type)) {
@@ -7695,7 +8717,7 @@ export function lowerNew(lowerer, expr) {
                     // throw only via the ctor body's later reads — it does NOT
                     // observe it before throwing, so dropping it is exact for
                     // effect-free operands; effectful ones keep the fence.
-                    const enc = lowerer.lowerExpr(expr.arguments[1]);
+                    const enc = lowerer.lowerExpr(expr.arguments.nodes[1]);
                     if (enc.kind === "strLit" || isSafeToRepeat(enc)) {
                         return {
                             kind: "libCall",
@@ -7745,7 +8767,7 @@ export function lowerNew(lowerer, expr) {
                     return bi?.module === "crypto" && bi.member === "X509Certificate";
                 })());
         if (isX509) {
-            const args = expr.arguments ?? [];
+            const args = expr.arguments?.nodes ?? [];
             if (args.length !== 1) {
                 lowerer.noLowering("X509Certificate with this argument shape", expr, "the supported form is new X509Certificate(readFileSync(path))");
             }
@@ -7838,29 +8860,55 @@ export function lowerNew(lowerer, expr) {
                 return lowerCheckedConstructor(lowerer, expr, callee);
             if (callee.type.kind !== "classval")
                 lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
-            lowerer.noteEdge(`%${info.def.name}.constructor`);
+            lowerer.noteEdge(classValueConstructor(info.def).fn);
             // Every constructor a value in this slot can dispatch to is a
             // descendant's — mark them reachable like a virtual edge.
             const below = (c) => {
                 for (const s of c.subclasses) {
-                    lowerer.noteEdge(`%${s.def.name}.constructor`);
+                    lowerer.noteEdge(classValueConstructor(s.def).fn);
                     below(s);
                 }
             };
             below(info);
-            const args = lowerer.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
-            return {
+            // EventEmitter and stream class values construct without options
+            // only: a slot of either may hold any of those classes, and the
+            // direct `new Readable({...})` lowering reads its options at compile
+            // time (EventEmitter's options have no lowering at all).
+            if ((info.builtinStream !== undefined || info.builtinEmitter) &&
+                (expr.arguments?.nodes.length ?? 0) > 0) {
+                lowerer.unsupported("SC1090", expr, `EventEmitter and stream class values constructed with options (construct with 'new ${info.def.name.slice(1)}({ ... })' directly)`);
+            }
+            // A program class whose constructor is the inherited runtime one
+            // takes no arguments through its class value either.
+            refuseInheritedBuiltinCtorArgs(lowerer, info, expr);
+            defineClassValueConstruct(lowerer, info);
+            const args = lowerer.completeArgs(expr.arguments?.nodes ?? [], classValueParams(info), loc, expr);
+            const built = constructedFromValue(lowerer, info, {
                 kind: "newValue",
                 callee,
                 args,
                 type: { kind: "object", className: info.def.name },
                 loc,
-            };
+            }, expr);
+            // A runtime class slot widened from a union (`[Readable, Writable]`'s
+            // elements hold EventEmitter values): the checker types the result as
+            // the union of the arms' instances, which the checked class view
+            // answers from the instance's class.
+            if (info.def.runtime) {
+                const resultT = lowerer.mapTypeOf(lowerer.typeOf(expr));
+                if (resultT?.kind === "union") {
+                    const asserted = checkedClassUnionAssertion(lowerer, built, resultT, loc);
+                    if (asserted)
+                        return asserted;
+                }
+            }
+            return built;
         }
         if (calleeT?.kind === "union") {
             const def = lowerer.unions.get(calleeT.unionId);
             if (def?.arms.some((a) => a.kind === "classval")) {
-                if (def.arms.every((arm) => arm.kind === "classval" || (isJsSourceFile(expr.getSourceFile()) && isUnitType(arm))) &&
+                if (def.arms.every((arm) => arm.kind === "classval" ||
+                    (isJsSourceFile(ts.getSourceFileOfNode(expr)) && isUnitType(arm))) &&
                     lowerer.dynConvertible(calleeT)) {
                     const callee = lowerer.lowerExprExpecting(expr.expression, DYN);
                     return lowerCheckedConstructor(lowerer, expr, callee);
@@ -7884,7 +8932,7 @@ export function lowerNew(lowerer, expr) {
         if (ctorName !== null) {
             const raw = lowerer.checker.getSymbolAtLocation(ctorName);
             const sym = raw && raw.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(raw) : raw;
-            const hint = sym && lowerer.isStdlibSymbol(sym) ? own(STDLIB_CTOR_HINTS, sym.name) : undefined;
+            const hint = sym && lowerer.isStdlibSymbol(sym) ? own(STDLIB_CTOR_HINTS, ts.symbolName(sym)) : undefined;
             if (hint !== undefined) {
                 lowerer.unsupported("SC1090", expr, hint);
             }
@@ -7896,13 +8944,22 @@ export function lowerNew(lowerer, expr) {
         (callee.type.kind === "dyn" ||
             ((callee.type.kind === "func" || callee.type.kind === "classval") &&
                 lowerer.dynConvertible(callee.type)))) {
-        return lowerCheckedConstructor(lowerer, expr, lowerer.coerceToExpected(callee, DYN));
+        let boxed = lowerer.coerceToExpected(callee, DYN);
+        // A plain function's box carries its name: the construction's
+        // prototype records it as `constructor`, which util.inspect prints
+        // (`F { a: 2 }`).
+        if (boxed.kind === "dynFrom" && boxed.fnName === undefined && callee.type.kind === "func") {
+            const name = jsFuncNameOf(expr.expression, lowerer);
+            if (name !== null)
+                boxed = { ...boxed, fnName: name };
+        }
+        return lowerCheckedConstructor(lowerer, expr, boxed);
     }
     lowerer.unsupported("SC1090", expr, "constructing values other than classes declared in the program");
 }
 function lowerCheckedConstructor(lowerer, expr, callee) {
     const loc = locOf(expr);
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.some(ts.isSpreadElement)) {
         const packed = lowerer.completeArgs(args, [{ type: DYN, mode: "dynRest" }], loc, expr)[0];
         return checkedClassConstructionPacked(lowerer, callee, packed, loc);