@scriptc/compiler 0.2.0 → 0.2.2

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

@@ -6,11 +6,11 @@ import { InternalCompilerError } from "../../errors.js";
  * hierarchy registration. */
 import * as ts from "../ts7/adapter.js";
 import { BOOL, DATE_T, DYN, F64, bytesOf, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals } from "../../ir/ir.js";
-import { MAX_GENERIC_INSTANCES, appendImplicitUndefinedReturn, bodyReadsArguments, generatorMeta, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
+import { MAX_GENERIC_INSTANCES, appendImplicitUndefinedReturn, bodyReadsArguments, generatorMeta, genericCallInstance, hasExplicitJsDocReturn, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
 import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm } from "../type-mapper.js";
 import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf } from "../program.js";
-import { PoisonError, dynFallbackType, dynUndefinedExpr, newFnCtx, own } from "./lowerer.js";
-import { lowerArrayConstructor, lowerMapSeedNew, lowerSetSeedNew } from "./lower-containers.js";
+import { PoisonError, dynFallbackType, dynUndefinedExpr, newFnCtx, nodeThrowExpr, own } from "./lowerer.js";
+import { lowerArrayConstructor, lowerMapSeedNew, lowerObjectConstructor, lowerSetSeedNew } from "./lower-containers.js";
 import { bufEncoding } from "./containers/bytes.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { lowerSearchParamsNew, lowerTextCodecNew } from "./lower-builtins.js";
@@ -26,10 +26,14 @@ 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 { classPrototypeData } from "./class-prototypes.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { lowerObjectFactoryNew } from "./object-factory-new.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.js";
+import { classPrototypeData } from "./class-prototypes.js";
+import { checkedClassConstruction, checkedClassConstructionPacked } from "./class-construction.js";
+import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js";
+import { reflectedClassStaticMethodValue } from "./class-method-values.js";
 export function returnsOnlyThis(member) {
     const body = member.body;
     const last = body?.statements.at(-1);
@@ -58,11 +62,20 @@ function functionLocalClass(decl) {
     }
     return false;
 }
-export function storedClassValueType(lowerer, expression) {
+export function storedClassValueType(lowerer, expression, visiting = new Set()) {
+    if (visiting.has(expression))
+        return null;
+    visiting.add(expression);
+    if (ts.isParenthesizedExpression(expression))
+        return storedClassValueType(lowerer, expression.expression, visiting);
+    if (ts.isClassExpression(expression) && !functionLocalClass(expression) && !lowerer.collectingExprClasses.has(expression)) {
+        const info = lowerer.lowerClassExpressionInfo(expression);
+        return { kind: "classval", className: info.def.name };
+    }
     if (ts.isPropertyAccessExpression(expression) && !expression.questionDotToken) {
         const member = nsMemberIdentOf(lowerer, expression);
         if (member)
-            return storedClassValueType(lowerer, member);
+            return storedClassValueType(lowerer, member, visiting);
     }
     if (expression.kind === ts.SyntaxKind.ThisKeyword) {
         const stored = lowerer.resolveThis();
@@ -71,10 +84,149 @@ export function storedClassValueType(lowerer, expression) {
     }
     if (ts.isIdentifier(expression)) {
         const stored = lowerer.peekLocal(expression) ?? lowerer.globalOf(expression);
-        if (stored?.type.kind === "classval")
+        if (stored?.type.kind === "classval" && lowerer.classes.has(stored.type.className))
             return stored.type;
+        const symbol = lowerer.resolveValueSymbol(expression);
+        const declaration = symbol && lowerer.checker.declarationsOf(symbol).find((decl) => ts.isVariableDeclaration(decl) && decl.initializer && (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0);
+        if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
+            const value = storedClassValueType(lowerer, declaration.initializer, visiting);
+            if (value?.kind === "classval")
+                return value;
+        }
+    }
+    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 declaration = constructor && ts.isConstructorDeclaration(constructor) ? constructor.parent : undefined;
+            if (declaration && ts.isClassExpression(declaration) && !functionLocalClass(declaration) &&
+                !lowerer.collectingExprClasses.has(declaration)) {
+                const info = lowerer.lowerClassExpressionInfo(declaration);
+                return { kind: "classval", className: info.def.name };
+            }
+        }
+    }
+    if (mapped?.kind === "classval" || !ts.isCallExpression(expression))
+        return mapped;
+    let callee = expression.expression;
+    let calls = 1;
+    const aliases = new Set();
+    for (;;) {
+        if (aliases.has(callee))
+            break;
+        aliases.add(callee);
+        if (ts.isParenthesizedExpression(callee)) {
+            callee = callee.expression;
+            continue;
+        }
+        if (ts.isCallExpression(callee)) {
+            calls++;
+            callee = callee.expression;
+            continue;
+        }
+        if (ts.isPropertyAccessExpression(callee)) {
+            const member = nsMemberIdentOf(lowerer, callee);
+            if (member) {
+                callee = member;
+                continue;
+            }
+        }
+        if (ts.isIdentifier(callee)) {
+            const symbol = lowerer.resolveValueSymbol(callee);
+            const declaration = symbol && lowerer.checker.declarationsOf(symbol).find((decl) => ts.isVariableDeclaration(decl) && decl.initializer && (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0);
+            if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
+                callee = declaration.initializer;
+                continue;
+            }
+        }
+        break;
+    }
+    if ((ts.isArrowFunction(callee) || ts.isFunctionExpression(callee)) && isJsSourceFile(callee.getSourceFile()) &&
+        !callee.typeParameters?.length && !lowerer.preparingClassFactories.has(callee)) {
+        const signature = lowerer.checker.getSignatureFromDeclaration(callee);
+        let result = signature && lowerer.checker.getReturnTypeOfSignature(signature);
+        for (let i = 1; result && i < calls; i++) {
+            const signatures = lowerer.checker.getCallSignatures(result);
+            result = signatures.length === 1 ? lowerer.checker.getReturnTypeOfSignature(signatures[0]) : undefined;
+        }
+        if (result && lowerer.checker.getConstructSignatures(result).length > 0) {
+            const returned = (value) => {
+                let type = value.type;
+                for (let i = 0; i < calls && type.kind === "func"; i++)
+                    type = type.ret;
+                return type.kind === "classval" ? type : null;
+            };
+            const home = callee.parent;
+            const generic = ts.isVariableDeclaration(home) && ts.isIdentifier(home.name) ? lowerer.genericFnOf(home.name) : null;
+            if (generic?.implicitParams && ts.isVariableDeclaration(home) && ts.isIdentifier(home.name)) {
+                const factory = lowerer.lowerGenericFnValue(home.name, generic);
+                const type = returned(factory);
+                if (type)
+                    return type;
+            }
+            lowerer.preparingClassFactories.add(callee);
+            const collecting = lowerer.collecting, sink = lowerer.diagSink;
+            lowerer.collecting = false;
+            lowerer.diagSink = null;
+            try {
+                const factory = lowerer.preparedClassFactories.get(callee) ?? lowerer.lowerLambda(callee);
+                lowerer.preparedClassFactories.set(callee, factory);
+                const type = returned(factory);
+                if (type)
+                    return type;
+            }
+            finally {
+                lowerer.collecting = collecting;
+                lowerer.diagSink = sink;
+                lowerer.preparingClassFactories.delete(callee);
+            }
+        }
     }
-    return lowerer.mapTypeOf(lowerer.typeOf(expression));
+    // A checked call can erase its returned constructor's ABI while the
+    // checker still identifies the class declaration. Collect that class in
+    // its factory's lexical scope before choosing the derived native layout.
+    // 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 cls = declaration && ts.isConstructorDeclaration(declaration) ? declaration.parent : null;
+        if (!cls || (!ts.isClassExpression(cls) && !ts.isClassDeclaration(cls)))
+            continue;
+        let factory;
+        for (let parent = cls.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
+            if (ts.isArrowFunction(parent) || ts.isFunctionExpression(parent))
+                factory = parent;
+            else if (ts.isFunctionLike(parent)) {
+                factory = undefined;
+                break;
+            }
+        }
+        if (!factory || !isJsSourceFile(factory.getSourceFile()) || factory.typeParameters?.length ||
+            !ts.isVariableDeclaration(factory.parent) || factory.parent.initializer !== factory ||
+            !ts.isVariableDeclarationList(factory.parent.parent) || !(factory.parent.parent.flags & ts.NodeFlags.Const) ||
+            !ts.isVariableStatement(factory.parent.parent.parent) || !ts.isSourceFile(factory.parent.parent.parent.parent) ||
+            lowerer.preparingClassFactories.has(factory))
+            continue;
+        if (!lowerer.preparedClassFactories.has(factory)) {
+            lowerer.preparingClassFactories.add(factory);
+            const collecting = lowerer.collecting, sink = lowerer.diagSink;
+            lowerer.collecting = false;
+            lowerer.diagSink = null;
+            try {
+                lowerer.preparedClassFactories.set(factory, lowerer.lowerLambda(factory));
+            }
+            finally {
+                lowerer.collecting = collecting;
+                lowerer.diagSink = sink;
+                lowerer.preparingClassFactories.delete(factory);
+            }
+        }
+        const resolved = lowerer.mapTypeOf(type);
+        if (resolved?.kind === "classval")
+            return resolved;
+    }
+    return mapped;
 }
 /** The KEY symbol behind a LATE-BOUND (`__@name@id`) property: resolved
    * from the argument of the element-access assignment that declared it
@@ -186,6 +338,10 @@ export function registerBuiltinErrorClasses(lowerer) {
                     { name: "%code", type: STRING },
                     { name: "%cause", type: DYN },
                     { name: "%causeEnumerable", type: BOOL },
+                    { name: "%messagePresent", type: BOOL },
+                    { name: "%messageEnumerable", type: BOOL },
+                    { name: "%namePresent", type: BOOL },
+                    { name: "%nameEnumerable", type: BOOL },
                     { name: "%stackFrames", type: STRING },
                     { name: "%stack", type: STRING },
                 ],
@@ -337,12 +493,102 @@ export function builtinStreamInfoOf(lowerer, symbol) {
 /** A dictionary lookup may be absent even when its checker type is a
  * required reference. Keep literal nullish fallbacks in inferred JS storage. */
 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) ||
+            (lowerer.typeOf(expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)))
+            return DYN;
+    }
+    if (type.kind === "array" || type.kind === "record")
+        return DYN;
+    // 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())) {
+        const assignment = expression.parent;
+        const left = ts.isBinaryExpression(assignment) ? assignment.left : null;
+        const field = left && ts.isPropertyAccessExpression(left) && left.expression.kind === ts.SyntaxKind.ThisKeyword ? left.name.text : null;
+        let owner = expression.parent;
+        while (owner && !ts.isClassDeclaration(owner) && !ts.isClassExpression(owner))
+            owner = owner.parent;
+        if (field && owner) {
+            let acceptsUnchecked = false;
+            const scan = (node) => {
+                if (acceptsUnchecked || node !== owner && (ts.isClassDeclaration(node) || ts.isClassExpression(node)))
+                    return;
+                if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword && node.left.name.text === field) {
+                    let rhs = node.right;
+                    while (ts.isParenthesizedExpression(rhs))
+                        rhs = rhs.expression;
+                    if (ts.isCallExpression(rhs) || ts.isElementAccessExpression(rhs))
+                        acceptsUnchecked = true;
+                }
+                node.forEachChild(scan);
+            };
+            scan(owner);
+            if (acceptsUnchecked)
+                return DYN;
+        }
+    }
     let node = expression;
     while (ts.isParenthesizedExpression(node))
         node = node.expression;
+    if (ts.isCallExpression(node) && type.kind === "bytes") {
+        let prototypeArgument = false;
+        for (const argument of node.arguments)
+            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) => {
+                    const member = ts.isBinaryExpression(decl) ? decl.left : decl;
+                    return ts.isPropertyAccessExpression(member) && ts.isPropertyAccessExpression(member.expression) &&
+                        member.expression.name.text === "prototype";
+                }))
+                    prototypeArgument = true;
+                // JS checkers can synthesize a property declaration for prototype
+                // assignments. Keep the source ownership proof when that happens.
+                let owner = node.parent;
+                while (owner && !(ts.isClassDeclaration(owner) || ts.isClassExpression(owner)))
+                    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) {
+                        if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression))
+                            continue;
+                        const left = statement.expression.left;
+                        if (statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(left) &&
+                            left.name.text === part.name.text && ts.isPropertyAccessExpression(left.expression) && left.expression.name.text === "prototype" &&
+                            ts.isIdentifier(left.expression.expression) && left.expression.expression.text === className)
+                            prototypeArgument = true;
+                    }
+                }
+            });
+        // A prototype-selected conversion can return different container kinds
+        // in subclasses even when JSDoc describes the base class's default.
+        if (prototypeArgument)
+            return DYN;
+    }
+    if (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
+        const ret = lowerer.declaredReturnType(node, node);
+        const arms = type.kind === "union" ? lowerer.unions.get(type.unionId)?.arms ?? [] : [type];
+        // Inferred arithmetic may return a checked Number or BigInt. Preserve
+        // the callable when its native return ABI differs from the checker slot.
+        if (arms.some((arm) => arm.kind === "func" && !typeEquals(arm.ret, ret)))
+            return DYN;
+    }
     if (node.kind === ts.SyntaxKind.NullKeyword)
         return withUnitArm(type, "nullT", lowerer.unions) ?? type;
     const inferred = lowerer.typeOf(node);
+    const scalar = (inferred.flags & ts.TypeFlags.BooleanLike) !== 0 ? "bool"
+        : (inferred.flags & ts.TypeFlags.NumberLike) !== 0 ? "f64"
+            : (inferred.flags & ts.TypeFlags.StringLike) !== 0 ? "string"
+                : (inferred.flags & ts.TypeFlags.BigIntLike) !== 0 ? "bigint"
+                    : (inferred.flags & ts.TypeFlags.ESSymbolLike) !== 0 ? "symbol" : null;
+    if (scalar && type.kind !== "dyn" && type.kind !== scalar &&
+        !(type.kind === "union" && lowerer.unions.get(type.unionId)?.arms.some((arm) => arm.kind === scalar)))
+        return DYN;
     for (const arm of inferred.isUnionType() ? ts.constituentTypes(inferred) : [inferred]) {
         if ((arm.flags & ts.TypeFlags.Undefined) !== 0)
             type = lowerer.withUndefinedArmOf(type) ?? type;
@@ -362,6 +608,56 @@ function jsFieldInitializerType(lowerer, type, expression) {
     }
     return type;
 }
+function inheritedJsFieldType(lowerer, decl, name, type) {
+    for (const expression of lowerer.inheritedJsFieldWrites.get(decl)?.get(name) ?? []) {
+        // Keep one shared layout, including sibling subclasses. A descendant
+        // initializer that exceeds the base slot needs checked JS storage.
+        if (!typeEquals(type, jsFieldInitializerType(lowerer, type, expression)))
+            return DYN;
+    }
+    return type;
+}
+function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
+    if (!isJsSourceFile(member.getSourceFile()) || member.type || member.asteriskToken || hasExplicitJsDocReturn(member))
+        return false;
+    const widened = (expression) => {
+        if (ts.isParenthesizedExpression(expression))
+            return widened(expression.expression);
+        if (ts.isConditionalExpression(expression))
+            return widened(expression.whenTrue) || widened(expression.whenFalse);
+        if (ts.isCallExpression(expression)) {
+            const callee = expression.expression;
+            const symbol = ts.isPropertyAccessExpression(callee) ? lowerer.checker.getSymbolAtLocation(callee.name)
+                : ts.isElementAccessExpression(callee) ? 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)))
+                return true;
+        }
+        const name = ts.isPropertyAccessExpression(expression) ? expression.name.text
+            : ts.isElementAccessExpression(expression) ? lowerer.foldedStringKeyOf(expression.argumentExpression) : null;
+        if (ts.isPropertyAccessExpression(expression)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(expression.name);
+            if (symbol && lowerer.checker.declarationsOf(symbol).some((declaration) => (ts.isGetAccessorDeclaration(declaration) || ts.isSetAccessorDeclaration(declaration)) && lowerer.checkedVirtualJsAccessors.has(declaration)))
+                return true;
+        }
+        if (name !== null && (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) &&
+            expression.expression.kind === ts.SyntaxKind.ThisKeyword) {
+            return fields.get(name)?.kind === "dyn" || inheritedJsFieldType(lowerer, decl, name, ret).kind === "dyn";
+        }
+        return false;
+    };
+    let result = false;
+    const scan = (node) => {
+        if (result || ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node) && node.expression && widened(node.expression))
+            result = true;
+        node.forEachChild(scan);
+    };
+    if (member.body)
+        scan(member.body);
+    return result;
+}
 /** The undefined-armed union of a JS class property's inferred type — the
    * honest slot for a field first assigned outside the constructor's top
    * level (undefined until the write runs, Node-exact). Null when the
@@ -803,12 +1099,17 @@ mixin) {
         // so the base's ClassInfo already exists here. An INSTANTIATION's
         // base is its family (whose base is the declared one) — the heritage
         // clause resolved when the family collected.
-        let base = inst ? inst.family : mixin ? mixin.base : null;
+        const computedBase = lowerer.computedClassBases.get(lowerer.classNamer(decl));
+        let base = inst ? inst.family : mixin ? mixin.base : computedBase?.classInfo ?? null;
         let callableBase;
+        let factoryBaseExpression;
         const adoptCallableBase = (expression) => {
-            if (!isJsSourceFile(decl.getSourceFile()) || functionLocalClass(decl) ||
-                !ts.isClassDeclaration(decl) || familyMode || inst || mixin)
+            if (familyMode || inst || mixin)
                 return false;
+            if (lowerer.computedCallableBases.has(decl)) {
+                callableBase = { expression, constructorId: `%g.${className}.base`, prototypeId: `%g.${className}.basePrototype` };
+                return true;
+            }
             const signatures = lowerer.checker.getCallSignatures(lowerer.typeOf(expression));
             const source = signatures.length === 1 ? lowerer.checker.signatureDeclaration(signatures[0]) : undefined;
             if (!source || !isJsSourceFile(source.getSourceFile()) ||
@@ -847,7 +1148,7 @@ mixin) {
                 }
             }
         }
-        for (const clause of inst || mixin ? [] : (decl.heritageClauses ?? [])) {
+        for (const clause of inst || mixin || computedBase ? [] : (decl.heritageClauses ?? [])) {
             // `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
@@ -884,8 +1185,6 @@ mixin) {
                 // (the class statement evaluates at its init position; a base
                 // block below it would still be uninitialized in Node).
                 if (!t.expression.questionDotToken && nsMemberIdentOf(lowerer, t.expression)) {
-                    if (t.typeArguments)
-                        lowerer.unsupported("SC1090", t, "extending generic classes");
                     if (memberSym)
                         fenceEarlyNsMemberRef(lowerer, t.expression, memberSym);
                     const stored = storedClassValueType(lowerer, t.expression);
@@ -896,6 +1195,8 @@ mixin) {
                             continue;
                         lowerer.unsupported("SC1090", t, `extending the namespace member '${t.expression.name.text}' (no class lowering)`);
                     }
+                    if (t.typeArguments)
+                        lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = nsBase;
                     continue;
                 }
@@ -960,8 +1261,17 @@ mixin) {
                     base = mixinBase;
                     continue;
                 }
+                const stored = storedClassValueType(lowerer, t.expression);
+                const factoryBase = stored?.kind === "classval" ? lowerer.classes.get(stored.className) : undefined;
+                if (factoryBase) {
+                    base = factoryBase;
+                    factoryBaseExpression = t.expression;
+                    continue;
+                }
             }
             if (!t || !ts.isIdentifier(t.expression)) {
+                if (t && adoptCallableBase(t.expression))
+                    continue;
                 lowerer.unsupported("SC1090", clause, "extending computed expressions");
             }
             const symbol = lowerer.resolveValueSymbol(t.expression);
@@ -1027,8 +1337,13 @@ mixin) {
                 lowerer.unsupported("SC1090", t, `extending classes not declared in the program ('${t.expression.text}')`);
             }
         }
-        if (base?.localClass && !functionLocalClass(decl))
-            lowerer.unsupported("SC1090", decl, "extending a function-local class outside a function");
+        if (base?.localClass && !functionLocalClass(decl) && !computedBase && !factoryBaseExpression) {
+            const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0];
+            if (heritage)
+                factoryBaseExpression = heritage.expression;
+            else
+                lowerer.unsupported("SC1090", decl, "extending a function-local class outside a function");
+        }
         if (lowerer.collectingExprClasses.has(decl)) {
             for (let parent = base; parent; parent = parent.base) {
                 if (parent.builtinEmitter || parent.builtinStream !== undefined) {
@@ -1078,6 +1393,14 @@ mixin) {
         const staticFields = [];
         const staticMethods = new Map();
         const staticBlocks = [];
+        const runtimeStatics = [];
+        const runtimePrototypeMembers = [];
+        // Public JS accessors need live constructor descriptors, including
+        // receiver-sensitive getters and setters inherited by subclasses.
+        const checkedStatics = isJsSourceFile(decl.getSourceFile()) && (base && hasRuntimeStatics(base) || decl.members.some((member) => ts.isAccessor(member) && !ts.isPrivateIdentifier(member.name) &&
+            member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
+            !decl.members.some((member) => member.name && ts.isPrivateIdentifier(member.name) &&
+                ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
         // GENERIC methods (own type parameters), instance and static: only
         // the SYNTAX is checked here — parameter/return types mention the
         // type parameters and cannot map yet; bodies lower per call-site
@@ -1126,6 +1449,18 @@ mixin) {
             });
         };
         for (const member of decl.members) {
+            if ((functionLocalClass(decl) || checkedStatics) && isJsSourceFile(decl.getSourceFile()) &&
+                (ts.isClassStaticBlockDeclaration(member) || ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) {
+                runtimeStatics.push(member);
+                continue;
+            }
+            if (functionLocalClass(decl) && isJsSourceFile(decl.getSourceFile()) &&
+                (ts.isMethodDeclaration(member) || ts.isAccessor(member)) && member.body &&
+                !ts.isPrivateIdentifier(member.name)) {
+                runtimePrototypeMembers.push(member);
+                if (ts.isComputedPropertyName(member.name) && classMemberNameOf(lowerer, member.name) === null)
+                    continue;
+            }
             if (ts.isClassStaticBlockDeclaration(member)) {
                 // Statics live on the FAMILY (JS has one class, one static
                 // storage, however many instantiations exist) — instantiations
@@ -1172,10 +1507,15 @@ mixin) {
                     (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                     member.initializer &&
                     member.postfixToken?.kind !== ts.SyntaxKind.QuestionToken) {
+                    const initializerSymbol = ts.isIdentifier(member.initializer) ? lowerer.resolveValueSymbol(member.initializer) : null;
+                    // Enum namespace aliases are erased; member reads fold through the checker.
+                    if (initializerSymbol && (initializerSymbol.flags & ts.SymbolFlags.Enum) !== 0)
+                        continue;
                     const type = lowerer.irTypeOf(member.name);
                     if (type.kind === "void")
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
-                    if (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile())) {
+                    if (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile()) &&
+                        (member.type !== undefined || (lowerer.typeOf(member.name).flags & ts.TypeFlags.Any) === 0)) {
                         lowerer.unsupported("SC1090", member.name, "'unknown'-typed static fields");
                     }
                     staticFields.push({
@@ -1237,7 +1577,14 @@ mixin) {
             // (every named member kind stores a PropertyName there).
             const memberName = member.name;
             if (errorRooted && memberName && classMemberNameOf(lowerer, memberName) === "cause") {
-                lowerer.unsupported("SC1090", memberName, "redeclaring Error.cause (pass the cause in the Error constructor options)");
+                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)");
+                    fieldOrder.push({ name: "cause", type: DYN, initializer: member.initializer,
+                        ...(member.initializer ? {} : { undefinedInitializer: locOf(member) }), redeclared: true, errorCause: true });
+                    continue;
+                }
+                lowerer.unsupported("SC1090", memberName, "Error.cause accessors");
             }
             // #PRIVATE members compile: their names ('#m') are unspellable by
             // any public identifier, so they ride the ordinary fields/methods
@@ -1351,33 +1698,45 @@ mixin) {
                     // get/set pair — declare the field and accessors explicitly.
                     lowerer.unsupported("SC1090", member, "auto-accessor fields ('accessor x')");
                 }
-                if (ts.isComputedPropertyName(member.name)) {
-                    const key = classSymbolKeyOf(lowerer, member.name.expression);
-                    if (!key || (!member.initializer && !isJsSourceFile(member.getSourceFile()))) {
-                        lowerer.unsupported("SC1090", member, "computed class fields without an initializer and a stable module-level literal Symbol()/Symbol.for() key");
+                if (ts.isComputedPropertyName(member.name) || ts.isStringLiteralLike(member.name) || ts.isNumericLiteral(member.name)) {
+                    const symbolKey = ts.isComputedPropertyName(member.name) ? classSymbolKeyOf(lowerer, member.name.expression) : null;
+                    const stringKey = ts.isComputedPropertyName(member.name) ? lowerer.foldedStringKeyOf(member.name.expression)
+                        : ts.isNumericLiteral(member.name) ? String(Number(member.name.text)) : member.name.text;
+                    const fieldName = symbolKey?.fieldName ?? stringKey;
+                    if (fieldName === null || (!member.initializer && !isJsSourceFile(member.getSourceFile()))) {
+                        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 ? lowerer.mapTypeOf(inferred) ?? dynFallbackType(lowerer, member, inferred) : DYN;
-                    const type = mapped ? jsOpenObjectType(member, mapped, lowerer.shapes, lowerer.unions) : null;
+                    let type = mapped?.kind === "record" && isJsSourceFile(member.getSourceFile()) && !member.type
+                        ? DYN : mapped ? jsOpenObjectType(member, mapped, lowerer.shapes, lowerer.unions) : null;
                     if (!type || type.kind === "void" || (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile())))
                         lowerer.badType(member, inferred);
+                    if (isJsSourceFile(member.getSourceFile())) {
+                        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 previous = fields.get(key.fieldName);
+                    const previous = fields.get(fieldName);
                     if (previous) {
-                        if (!symbolFields.has(key.identity)) {
-                            lowerer.unsupported("SC1090", member.name, `distinct keys sharing the printable name '${symbolFieldDisplayName(key.fieldName)}' in one class`);
+                        if (symbolKey && !symbolFields.has(symbolKey.identity)) {
+                            lowerer.unsupported("SC1090", member.name, `distinct keys sharing the printable name '${symbolFieldDisplayName(fieldName)}' in one class`);
                         }
                         if (!typeEquals(previous, type)) {
-                            lowerer.unsupported("SC1090", member.name, "redeclaring symbol-keyed fields at a different type");
+                            lowerer.unsupported("SC1090", member.name, "redeclaring computed fields at a different type");
                         }
-                        fieldOrder.push({ name: key.fieldName, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}), redeclared: true });
+                        fieldOrder.push({ name: fieldName, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}), redeclared: true });
                     }
                     else {
-                        fields.set(key.fieldName, type);
-                        fieldOrder.push({ name: key.fieldName, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}) });
+                        fields.set(fieldName, type);
+                        fieldOrder.push({ name: fieldName, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}) });
                     }
-                    symbolFields.set(key.identity, key.fieldName);
+                    if (symbolKey)
+                        symbolFields.set(symbolKey.identity, fieldName);
                     continue;
                 }
                 // #private fields ride the ordinary field machinery — the '#'
@@ -1426,11 +1785,36 @@ 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 (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression) ||
+                            statement.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+                            continue;
+                        const left = statement.expression.left;
+                        if (!ts.isPropertyAccessExpression(left) || left.expression.kind !== ts.SyntaxKind.ThisKeyword || left.name.text !== member.name.text)
+                            continue;
+                        type = statement.expression.right.kind === ts.SyntaxKind.NullKeyword ? DYN : jsFieldInitializerType(lowerer, type, statement.expression.right);
+                    }
+                }
+                // Unannotated JavaScript callback slots retain the original
+                // callable and its receiver instead of adapting its signature.
+                if (isJsSourceFile(member.getSourceFile()) && !member.type &&
+                    !/@type\b/.test(member.getSourceFile().text.slice(member.pos, member.getStart())) &&
+                    (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") {
                     type = lowerer.withUndefinedArmOf(type) ?? DYN;
                 }
+                if (isJsSourceFile(member.getSourceFile())) {
+                    type = inheritedJsFieldType(lowerer, decl, member.name.text, type);
+                    if (base?.fields.get(member.name.text)?.kind === "dyn")
+                        type = DYN;
+                    if (base && !fields.has(member.name.text) && lowerer.dynConvertible(type))
+                        type = DYN;
+                }
                 if (type.kind === "void")
                     lowerer.badType(member.name, lowerer.typeOf(member.name));
                 // Bundled JS declares fields without annotations before assigning
@@ -1650,7 +2034,7 @@ mixin) {
                 // a generic-class instantiation's member.
                 if (implicitMonoFile(decl.getSourceFile()) && !functionLocalClass(decl) &&
                     ts.isIdentifier(member.name) &&
-                    !lowerer.virtualJsMethods.has(member) &&
+                    !lowerer.virtualJsMethods.has(member) && !lowerer.prototypeMethodAccesses.has(member.name.text) &&
                     inst === undefined && decl.typeParameters === undefined &&
                     !fields.has(member.name.text) &&
                     !lowerer.findMethodOn(base, member.name.text) &&
@@ -1669,6 +2053,36 @@ mixin) {
                     }
                 }
                 const { shapes, funcType: ft } = lowerer.lambdaSignature(member);
+                const fieldRet = ft.ret.kind === "promise" ? ft.ret.inner : ft.ret;
+                if (returnsWidenedJsField(lowerer, decl, member, fields, fieldRet)) {
+                    ft.ret = ft.ret.kind === "promise" ? { ...ft.ret, inner: DYN } : DYN;
+                }
+                if (lowerer.checkedVirtualJsMethods.has(member)) {
+                    for (const shape of shapes) {
+                        shape.type = DYN;
+                        if (shape.bodyType)
+                            shape.bodyType = DYN;
+                    }
+                    ft.params = shapes.map((shape) => shape.type);
+                    if (ft.ret.kind !== "void" || lowerer.checkedVirtualJsValueReturns.has(member))
+                        ft.ret = DYN;
+                }
+                // 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()) && !member.type && !hasExplicitJsDocReturn(member) && ft.ret.kind === "symbol")
+                    ft.ret = DYN;
+                if (isJsSourceFile(member.getSourceFile()) && lowerer.prototypeMethodAccesses.has(mName) &&
+                    !lowerer.findMethodOn(base, mName)?.declarer.def.runtime &&
+                    shapes.every((p) => p.mode === "required" || p.mode === "omittable")) {
+                    for (const shape of shapes) {
+                        shape.type = DYN;
+                        if (shape.bodyType)
+                            shape.bodyType = DYN;
+                    }
+                    ft.params = shapes.map((shape) => shape.type);
+                    if (ft.ret.kind !== "void")
+                        ft.ret = DYN;
+                }
                 // JS subclasses can add parameters to a method. Reserve checked
                 // argument slots in the base before constructing its vtable; shorter
                 // bodies ignore them and omitted call arguments become undefined.
@@ -1704,6 +2118,12 @@ mixin) {
                 // `m(x: number | undefined)` interchange soundly in overrides.
                 const overridden = lowerer.findMethodOn(base, mName);
                 if (overridden && isJsSourceFile(member.getSourceFile())) {
+                    // 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.
+                    if (!member.type && ft.ret.kind === "dyn" && overridden.sig.ret.kind !== "dyn" &&
+                        !overridden.sig.async && !overridden.sig.gen)
+                        ft.ret = overridden.sig.ret;
                     // Fluent overrides return the same native receiver. Keep the
                     // inherited return ABI and upcast `this` when lowering returns.
                     if (overridden.sig.ret.kind === "object" && base &&
@@ -1735,20 +2155,30 @@ mixin) {
                     shapes.push(...overridden.sig.params.slice(shapes.length).map((p) => ({ type: p.type, mode: "omittable" })));
                 }
                 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, ft.ret))) {
                     const fencedJsOverride = isJsSourceFile(member.getSourceFile()) &&
                         overridden.declarer.decl !== null && isJsSourceFile(overridden.declarer.decl.getSourceFile()) &&
-                        member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) !== true &&
-                        overridden.sig.async !== true &&
-                        member.asteriskToken === undefined && overridden.sig.gen === undefined;
+                        overridden.sig.gen === undefined;
                     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));
+                            overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) &&
+                            !member.parameters.some((parameter, index) => {
+                                if (!parameter.initializer)
+                                    return false;
+                                const baseMember = overridden.declarer.decl?.members.find((candidate) => ts.isMethodDeclaration(candidate) && classMemberNameOf(lowerer, candidate.name) === mName);
+                                const inherited = baseMember && ts.isMethodDeclaration(baseMember) ? baseMember.parameters[index]?.initializer : undefined;
+                                if (!inherited)
+                                    return false;
+                                const ownType = lowerer.mapTypeOf(lowerer.typeOf(parameter.initializer));
+                                const baseType = lowerer.mapTypeOf(lowerer.typeOf(inherited));
+                                return ownType !== null && baseType !== null && !typeEquals(ownType, baseType);
+                            });
                         methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), returnOnly
                             ? `overriding method '${mName}' with a different return type (the native return type must match the base declaration exactly)`
                             : `overriding method '${mName}' with a different signature (the native parameter and return types must match the base declaration exactly)`));
@@ -1765,10 +2195,18 @@ mixin) {
                 // 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)) {
-                    lowerer.unsupported("SC1090", member.name, `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)`);
+                    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()))
+                        methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), message));
+                    else
+                        lowerer.unsupported("SC1090", member.name, message);
                 }
                 if (overridden && (member.asteriskToken !== undefined || overridden.sig.gen !== undefined)) {
-                    lowerer.unsupported("SC1090", member.name, `overriding the generator method '${mName}' (generator methods dispatch statically — a virtual slot cannot enter their spawn wrapper)`);
+                    const message = `overriding the generator method '${mName}' (generator methods dispatch statically — a virtual slot cannot enter their spawn wrapper)`;
+                    if (isJsSourceFile(member.getSourceFile()))
+                        methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), message));
+                    else
+                        lowerer.unsupported("SC1090", member.name, message);
                 }
                 // A GENERATOR method carries its channels on the sig:
                 // the body lowers as a generator IrFunction (`this` as param 0),
@@ -1803,9 +2241,19 @@ mixin) {
                 const isGet = ts.isGetAccessor(member);
                 // #private accessors collect as "get:#x"/"set:#x" — the same
                 // reserved spelling, one more unspellable segment.
-                if (!ts.isIdentifier(member.name) && !ts.isPrivateIdentifier(member.name)) {
+                const prop = classMemberNameOf(lowerer, member.name);
+                if (prop === null) {
                     lowerer.unsupported("SC1090", member, "computed accessor names");
                 }
+                if (ts.isComputedPropertyName(member.name)) {
+                    const key = classSymbolKeyOf(lowerer, member.name.expression);
+                    if (key) {
+                        if ([...symbolMethods, ...symbolFields].some(([identity, name]) => name === prop && identity !== key.identity)) {
+                            lowerer.unsupported("SC1090", member.name, `distinct symbol keys sharing the printable name '${symbolFieldDisplayName(prop)}' in one class`);
+                        }
+                        symbolMethods.set(key.identity, prop);
+                    }
+                }
                 // ABSTRACT accessors are the abstract-method story with property
                 // syntax: body-less by definition, they enter `methods` (marked
                 // abstract) as their "get:x"/"set:x" halves — slot declaration
@@ -1813,9 +2261,15 @@ mixin) {
                 const abstractAccessor = ts.getModifiers(member)?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) === true;
                 if (!member.body && !abstractAccessor)
                     lowerer.unsupported("SC1090", member, "bodyless accessors");
-                const prop = member.name.text;
                 const mName = `${isGet ? "get" : "set"}:${prop}`;
-                if (fields.has(prop)) {
+                if (fields.has(prop) && isJsSourceFile(decl.getSourceFile()) && base?.fields.has(prop) &&
+                    !fieldOrder.some((field) => field.name === prop)) {
+                    // JS may override an inherited data field with a prototype
+                    // accessor. Retain the base storage prefix for its constructor;
+                    // property dispatch on this subclass selects the accessor.
+                    fields.delete(prop);
+                }
+                if (fields.has(prop) && !((prop === "message" || prop === "name") && base && (base.def.name === "%Error" || lowerer.isSubclassOf(base.def.name, "%Error")))) {
                     // tsc rejects field/accessor mixing (TS2610/2611); defensive.
                     lowerer.unsupported("SC1090", member.name, "accessors sharing a name with a field");
                 }
@@ -1830,6 +2284,13 @@ mixin) {
                     // tsc rejects optional/default/rest setter params (TS1051-53).
                     sig = { params: lowerer.paramShapes(member.parameters), ret: VOID };
                 }
+                if (lowerer.checkedVirtualJsAccessors.has(member)) {
+                    if (isGet)
+                        sig.ret = DYN;
+                    else
+                        for (const parameter of sig.params)
+                            parameter.type = DYN;
+                }
                 // One property, ONE type: tsc (5.1+) admits get/set pairs with
                 // unrelated annotated types; a property slot here has a single
                 // IR type, so the pair must agree exactly.
@@ -2016,7 +2477,11 @@ mixin) {
                         if (fields.has(name) || hasAccessor(name))
                             continue;
                         if (methods.has(name) || lowerer.findMethodOn(base, name)) {
-                            lowerer.unsupported("SC1090", assign, "constructor-assigned fields shadowing methods");
+                            // An own JS callable shadows its prototype declaration.
+                            // Keep the method in the prototype and store the assigned
+                            // value in the instance property bag.
+                            lowerer.prototypeMethodAccesses.set(name, assign);
+                            continue;
                         }
                         const sym = lowerer.checker.getSymbolAtLocation(assign);
                         const t = sym ? lowerer.checker.getTypeOfSymbol(sym) : undefined;
@@ -2057,6 +2522,11 @@ mixin) {
                                     type = widened;
                             }
                         }
+                        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))
+                            type = DYN;
                         fields.set(name, type);
                         fieldOrder.push({ name, type, initializer: undefined });
                         continue;
@@ -2073,18 +2543,30 @@ mixin) {
                     if (lhs && ts.isElementAccessExpression(lhs) &&
                         lhs.expression.kind === ts.SyntaxKind.ThisKeyword) {
                         const key = classSymbolKeyOf(lowerer, lhs.argumentExpression);
-                        if (!key)
+                        const stringKey = lowerer.foldedStringKeyOf(lhs.argumentExpression);
+                        const fieldName = key?.fieldName ?? stringKey;
+                        if (fieldName === null) {
+                            if (lowerer.mapTypeOf(lowerer.typeOf(lhs.argumentExpression))?.kind === "symbol") {
+                                lowerer.unsupported("SC1090", lhs, "symbol-keyed class fields require a stable module-level key");
+                            }
+                            continue;
+                        }
+                        if (!key && (fields.has(fieldName) || hasAccessor(fieldName)))
                             continue;
+                        if (!key && (methods.has(fieldName) || lowerer.findMethodOn(base, fieldName))) {
+                            lowerer.prototypeMethodAccesses.set(fieldName, lhs);
+                            continue;
+                        }
                         // A key already declared (own or inherited) makes later
                         // assignments writes, not declarations.
-                        if (symbolFields.has(key.identity))
+                        if (key && symbolFields.has(key.identity))
                             continue;
-                        if (fields.has(key.fieldName)) {
+                        if (fields.has(fieldName)) {
                             // Two DISTINCT Symbol(...) consts with one description in
                             // one layout would need one printable name for two slots.
-                            lowerer.unsupported("SC1090", lhs, `distinct symbol keys sharing the printable name '${symbolFieldDisplayName(key.fieldName)}' in one class`);
+                            lowerer.unsupported("SC1090", lhs, `distinct symbol keys sharing the printable name '${symbolFieldDisplayName(fieldName)}' in one class`);
                         }
-                        const propSym = lateBoundByKey.get(key.sym);
+                        const propSym = key ? lateBoundByKey.get(key.sym) : instType ? lowerer.checker.getPropertyOfType(instType, fieldName) : undefined;
                         // tsgo does not synthesize the late-bound `__@name@id`
                         // property for a JS `this[k] = v` declaration (the finding-5
                         // family: no expando/late-bound synthesis in its stricter
@@ -2104,9 +2586,13 @@ mixin) {
                             type = jsOpenObjectType(lhs, type, lowerer.shapes, lowerer.unions);
                         if (!type || type.kind === "void")
                             lowerer.badType(lhs, t ?? lowerer.typeOf(lhs));
-                        fields.set(key.fieldName, type);
-                        symbolFields.set(key.identity, key.fieldName);
-                        fieldOrder.push({ name: key.fieldName, type, initializer: undefined });
+                        type = inheritedJsFieldType(lowerer, decl, fieldName, type);
+                        if (base && lowerer.dynConvertible(type))
+                            type = DYN;
+                        fields.set(fieldName, type);
+                        if (key)
+                            symbolFields.set(key.identity, fieldName);
+                        fieldOrder.push({ name: fieldName, type, initializer: undefined });
                     }
                 }
             }
@@ -2152,7 +2638,8 @@ mixin) {
                 // TypeScript classes keep the loud fence too: an annotated
                 // program can spell `T | undefined` itself.
                 if (isJsSourceFile(decl.getSourceFile())) {
-                    const armed = undefArmedFieldType(lowerer, p);
+                    const original = undefArmedFieldType(lowerer, p);
+                    const armed = original === null ? null : inheritedJsFieldType(lowerer, decl, p.name, original);
                     if (armed !== null) {
                         // Unknown JS properties use the instance bag: they do not
                         // exist until assigned, and a subclass may declare the same
@@ -2197,7 +2684,13 @@ mixin) {
         const ctorParams = ctor && !mixinForwarding
             ? lowerer.paramShapes(ctor.parameters)
             : (base?.ctorParams ?? (callableBase ? [{ type: DYN, mode: "dynRest" }] : []));
+        if (ctor && !mixinForwarding && isJsSourceFile(ctor.getSourceFile()) &&
+            !ctorParams.some((shape) => shape.mode === "rest" || shape.mode === "dynRest" || shape.mode === "islandRest") && bodyReadsArguments(ctor)) {
+            ctorParams.push({ type: DYN, mode: "arguments" });
+        }
         const info = {
+            ...(runtimeStatics.length || checkedStatics ? { runtimeStatics } : {}),
+            ...(runtimePrototypeMembers.length ? { runtimePrototypeMembers } : {}),
             def: {
                 name: className,
                 // The JS-observable .name (the class object's name string and
@@ -2237,6 +2730,7 @@ mixin) {
             ...(paramProps.length > 0 ? { paramProps } : {}),
             base,
             ...(callableBase ? { callableBase } : {}),
+            ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
             throwingSetters,
             staticFields,
@@ -2297,7 +2791,15 @@ mixin) {
         if (base)
             base.subclasses.push(info);
         lowerer.classes.set(className, info);
-        if (callableBase) {
+        if (computedBase && !functionLocalClass(decl)) {
+            info.def.baseValueGlobal = `%g.${className}.computedBase`;
+            lowerer.globalsList.push({ id: info.def.baseValueGlobal, name: `${className} base`, type: computedBase.value.type, mutable: false });
+        }
+        if (factoryBaseExpression && !functionLocalClass(decl)) {
+            info.def.baseValueGlobal = `%g.${className}.computedBase`;
+            lowerer.globalsList.push({ id: info.def.baseValueGlobal, name: `${className} base`, type: { kind: "classval", className: base.def.name }, mutable: false });
+        }
+        if (callableBase && !functionLocalClass(decl)) {
             lowerer.globalsList.push({ id: callableBase.constructorId, name: `${className} base`, type: DYN, mutable: false }, { id: callableBase.prototypeId, name: `${className} base prototype`, type: DYN, mutable: false });
         }
         // A NAMED class binds its name (declarations in their scope, class
@@ -2487,10 +2989,28 @@ function withInstanceBindings(lowerer, info, fn) {
    * field, like fieldInitStmts; a block lowers as the block statement it
    * is, so its statements poison individually inside lowerStmts. */
 export function lowerStaticFieldInits(lowerer, info) {
+    if (info.localClass)
+        return [];
     // Mixin instantiations lower their initializers under the
     // instantiation's bindings/context (a no-op for everything else —
     // generic FAMILIES own their statics and carry no genericInstance).
-    return withInstanceBindings(lowerer, info, () => lowerStaticFieldInitsInner(lowerer, info));
+    const diagsBefore = lowerer.diags.length;
+    try {
+        return withInstanceBindings(lowerer, info, () => lowerStaticFieldInitsInner(lowerer, info));
+    }
+    catch (error) {
+        // Heritage and decorators run before the per-field recovery below.
+        // Keep their refusal attached to the class declaration instead of
+        // 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 (fence)
+                return [fence];
+        }
+        return [];
+    }
 }
 function lowerStaticFieldInitsInner(lowerer, info) {
     // Decoration first: TC39 evaluates decorator expressions, creates the
@@ -2498,14 +3018,41 @@ function lowerStaticFieldInitsInner(lowerer, info) {
     // initializers and static blocks (verified against Node — the
     // decorated result is what `this`/the class name mean inside them).
     const out = [...lowerClassDecoration(lowerer, info)];
+    const computedBase = info.decl ? lowerer.computedClassBases.get(lowerer.classNamer(info.decl)) : undefined;
+    if (info.factoryBaseExpression && info.def.baseValueGlobal) {
+        const loc = locOf(info.factoryBaseExpression);
+        const type = { kind: "classval", className: info.base.def.name };
+        out.push({ kind: "assign", localId: info.def.baseValueGlobal, value: lowerer.lowerExprExpecting(info.factoryBaseExpression, type), loc });
+        out.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classInherit", args: [
+                    lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN),
+                    lowerer.coerceToExpected({ kind: "varRef", localId: info.def.baseValueGlobal, type, loc }, DYN),
+                ], type: DYN, loc }, loc });
+    }
+    if (computedBase && info.def.baseValueGlobal) {
+        const loc = computedBase.value.loc;
+        out.push({ kind: "assign", localId: info.def.baseValueGlobal, value: computedBase.value, loc });
+        out.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classInherit", args: [
+                    lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN),
+                    lowerer.coerceToExpected({ kind: "varRef", localId: info.def.baseValueGlobal, type: computedBase.value.type, loc }, DYN),
+                ], type: DYN, loc }, loc });
+    }
     if (info.callableBase) {
         const { expression, constructorId, prototypeId } = info.callableBase;
         const loc = locOf(expression);
-        out.push({ kind: "assign", localId: constructorId, value: lowerer.lowerExprExpecting(expression, DYN), loc }, { kind: "assign", localId: prototypeId, value: { kind: "libCall", fn: "dyn.classBasePrototype",
+        out.push({ kind: "assign", localId: constructorId, value: info.decl && lowerer.computedCallableBases.has(info.decl)
+                ? lowerer.coerceToExpected(lowerer.computedCallableBases.get(info.decl), DYN)
+                : lowerer.lowerExprExpecting(expression, DYN), loc }, { kind: "assign", localId: prototypeId, value: { kind: "libCall", fn: "dyn.classBasePrototype",
                 args: [{ kind: "varRef", localId: constructorId, type: DYN, loc }], type: DYN, loc }, loc });
         const prototype = classPrototypeData(lowerer, info, loc);
         if (prototype)
             out.push({ kind: "exprStmt", expr: prototype, loc });
+        out.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classInherit", args: [
+                    lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN),
+                    { kind: "varRef", localId: constructorId, type: DYN, loc },
+                ], type: DYN, loc }, loc });
+    }
+    if (info.runtimeStatics && !info.localClass && info.decl) {
+        out.push({ kind: "exprStmt", expr: initializeRuntimeStatics(lowerer, info, classValueRef(lowerer, info, info.decl)), loc: locOf(info.decl) });
     }
     const items = [
         ...info.staticFields.map((f) => ({ pos: f.initializer.getStart(), kind: "field", f })),
@@ -2523,12 +3070,23 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         lowerer.bumpFileStat(locOf(f.initializer).file, "total");
         const diagsBefore = lowerer.diags.length;
         try {
-            // `this` in a static field initializer names the CLASS (like a
-            // static block's), with arrows transparent and this-binding
-            // function forms opaque — the static-block rule verbatim, named
-            // here so the generic outside-a-method fence never fires first.
-            rejectStaticThis(lowerer, f.initializer, () => "'this' in static field initializers (it names the class — reference the class by name instead)", true);
-            const value = lowerer.lowerExprExpecting(f.initializer, f.type);
+            const previousThis = lowerer.ctx.thisLocal;
+            const receiver = f.initializer.kind === ts.SyntaxKind.ThisKeyword || hasStaticThis(f.initializer)
+                ? lowerer.declareHiddenLocal("%staticThis", { kind: "classval", className: info.def.name }) : null;
+            if (receiver) {
+                lowerer.noteEdge(`%${info.def.name}.constructor`);
+                out.push({ kind: "varDecl", localId: receiver.id, init: { kind: "classRef", className: info.def.name,
+                        type: receiver.type, loc: locOf(f.initializer) }, loc: locOf(f.initializer) });
+            }
+            let value;
+            try {
+                if (receiver)
+                    lowerer.ctx.thisLocal = receiver;
+                value = lowerer.lowerExprExpecting(f.initializer, f.type);
+            }
+            finally {
+                lowerer.ctx.thisLocal = previousThis;
+            }
             out.push({ kind: "assign", localId: f.globalId, value, loc: locOf(f.initializer) });
         }
         catch (e) {
@@ -2793,6 +3351,9 @@ export function findGenericStaticOn(lowerer, info, name) {
    * module function — the declared-function-as-value rule verbatim
    * (interned by the backend, so `C.m === C.m` holds). */
 function staticMethodValue(lowerer, declarer, name, sig, blame, loc) {
+    const reflected = reflectedClassStaticMethodValue(lowerer, declarer, name);
+    if (reflected)
+        return reflected;
     const fnName = `%${declarer.def.name}.static:${name}`;
     lowerer.noteEdge(fnName);
     const funcType = {
@@ -2815,6 +3376,11 @@ function staticMethodValue(lowerer, declarer, name, sig, blame, loc) {
 export function classValueRef(lowerer, info, blame) {
     const display = info.def.name.replace(/^%|^%m\d+\./, "");
     fenceDecorationThrows(lowerer, info, blame);
+    if (info.localClass && ts.isIdentifier(blame)) {
+        const stored = lowerer.resolveLocal(blame);
+        if (stored)
+            return lowerer.coerceToExpected({ kind: "varRef", localId: stored.id, type: stored.type, loc: locOf(blame) }, { kind: "classval", className: info.def.name });
+    }
     if (info.localClass && !ts.isClassExpression(blame) && !ts.isClassDeclaration(blame)) {
         lowerer.unsupported("SC1090", blame, "named self references inside function-local classes");
     }
@@ -2879,9 +3445,12 @@ export function staticFieldWriteTarget(lowerer, access) {
    * fall through to the ordinary chain so the static fence or the
    * generic member rejection names the site. */
 export function lowerStaticFieldRead(lowerer, expr) {
+    if (expr.name.text === "prototype")
+        return null;
     if (expr.questionDotToken)
         return null;
-    if (!ts.isIdentifier(expr.expression) && expr.expression.kind !== ts.SyntaxKind.ThisKeyword)
+    if (!ts.isIdentifier(expr.expression) && expr.expression.kind !== ts.SyntaxKind.ThisKeyword &&
+        exactClassOfReceiver(lowerer, expr.expression) === null)
         return null;
     const symbol = ts.isIdentifier(expr.expression) ? lowerer.resolveValueSymbol(expr.expression) : null;
     const info = (symbol ? lowerer.classBySymbol.get(symbol) : undefined) ??
@@ -2903,6 +3472,9 @@ export function lowerStaticFieldRead(lowerer, expr) {
         return null;
     const loc = locOf(expr);
     const found = findStaticOn(lowerer, info, expr.name.text);
+    if (hasRuntimeStatics(info) && !found?.field)
+        return { kind: "dynKeyGet", value: lowerer.coerceToExpected(classValueRef(lowerer, info, expr.expression), DYN),
+            key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc };
     // A #private static resolves only through the DECLARING class's own
     // name: in JS the brand lives on that one constructor object, so
     // `D.#s` (a subclass receiver) throws Node's TypeError instead of
@@ -2930,9 +3502,18 @@ export function lowerStaticFieldRead(lowerer, expr) {
     if (expr.name.text === "name" && info.def.jsName !== undefined) {
         return { kind: "strLit", value: info.def.jsName, type: STRING, loc };
     }
+    if (info.callableBase)
+        return { kind: "dynKeyGet", value: lowerer.coerceToExpected(classValueRef(lowerer, info, expr.expression), DYN),
+            key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc };
     const data = classStaticDataFor(lowerer, info, expr.name.text, loc);
-    if (data)
-        return { kind: "dynKeyGet", value: data, key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc };
+    if (data) {
+        const value = { kind: "dynKeyGet", value: data, key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc };
+        // 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()) ? null : lowerer.mapTypeOf(lowerer.typeOf(expr));
+        return type ? lowerer.coerceToExpected(value, type) : value;
+    }
     return null;
 }
 /** NamedEvaluation's answer for a class expression's `.name`: its own
@@ -2987,13 +3568,29 @@ export function lowerClassExpressionInfo(lowerer, expr) {
         lowerer.unsupported("SC1090", expr, "function-local classes with private brands");
     }
     if (local && (expr.typeParameters?.length ||
-        decoratorNodesOf(expr).length || expr.members.some((member) => ts.isClassStaticBlockDeclaration(member) || decoratorNodesOf(member).length ||
-        ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ||
+        decoratorNodesOf(expr).length || expr.members.some((member) => decoratorNodesOf(member).length ||
+        (!isJsSourceFile(expr.getSourceFile()) && (ts.isClassStaticBlockDeclaration(member) ||
+            ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) ||
         (ts.isMethodDeclaration(member) && member.typeParameters?.length)))) {
         lowerer.unsupported("SC1090", expr, "function-local classes with statics, decorators, or generic members");
     }
     lowerer.collectingExprClasses.add(expr);
     try {
+        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;
+            if (heritage && (ts.isCallExpression(heritage) ||
+                ts.isIdentifier(heritage) && (lowerer.peekLocal(heritage) ?? lowerer.globalOf(heritage)) != null)) {
+                let value = lowerer.lowerExpr(heritage);
+                const known = value.type.kind === "dyn" ? storedClassValueType(lowerer, heritage) : null;
+                if (known?.kind === "classval")
+                    value = lowerer.coerceToExpected(value, known);
+                const base = value.type.kind === "classval" ? lowerer.classes.get(value.type.className) : undefined;
+                if (base)
+                    lowerer.computedClassBases.set(lowerer.classNamer(expr), { value, classInfo: base });
+                else if (value.type.kind === "dyn" || value.type.kind === "func")
+                    lowerer.computedCallableBases.set(expr, value);
+            }
+        }
         lowerer.collectClassShapeInner(expr, namedEvaluationName(expr));
     }
     finally {
@@ -3022,7 +3619,7 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     // drains it), which is JS's order for whole-initializer positions.
     // Anything subtler (multi-declarator statements, arguments evaluated
     // after other side effects) is a named fence, never a reordering.
-    if (info.staticFields.length > 0 || (info.staticBlocks?.length ?? 0) > 0) {
+    if (!local && (info.callableBase || info.def.baseValueGlobal || info.runtimeStatics || info.staticFields.length > 0 || (info.staticBlocks?.length ?? 0) > 0)) {
         let holder = expr.parent;
         while (ts.isParenthesizedExpression(holder) || ts.isClassExpression(holder) ||
             ts.isHeritageClause(holder) || ts.isExpressionWithTypeArguments(holder)) {
@@ -3042,7 +3639,6 @@ export function lowerClassExpressionInfo(lowerer, expr) {
         if (!wholeInit) {
             lowerer.unsupported("SC1090", expr, "class expressions with static initializers or static blocks outside a whole-initializer position (their declaration-time code must run exactly where the expression evaluates — bind the class in its own top-level `const C = class …` statement)");
         }
-        lowerer.pendingClassExprInits.push(...lowerer.lowerStaticFieldInits(info));
     }
     return info;
 }
@@ -3068,6 +3664,11 @@ export function lowerClassExpression(lowerer, expr) {
         }
     }
     const info = lowerClassExpressionInfo(lowerer, expr);
+    if (!info.localClass && !info.expressionInitializationEmitted &&
+        (info.callableBase || info.def.baseValueGlobal || info.runtimeStatics || info.staticFields.length > 0 || (info.staticBlocks?.length ?? 0) > 0)) {
+        info.expressionInitializationEmitted = true;
+        lowerer.pendingClassExprInits.push(...lowerer.lowerStaticFieldInits(info));
+    }
     if (info.localClass && !info.localClass.ready) {
         const context = newFnCtx(true, null, null, VOID);
         info.localClass.context = context;
@@ -3083,6 +3684,7 @@ export function lowerClassExpression(lowerer, expr) {
                 info.def.localCaptures.push({ localId: "%base", name: "base", type: { kind: "classval", className: info.base.def.name } });
             }
             info.localClass.ready = true;
+            lowerer.onExprClassCollected?.(info);
         }
         finally {
             lowerer.fnStack.pop();
@@ -3090,9 +3692,27 @@ export function lowerClassExpression(lowerer, expr) {
         }
     }
     const value = classValueRef(lowerer, info, expr);
+    if (info.localClass && info.callableBase && value.kind === "classRef") {
+        const loc = locOf(expr);
+        const base = lowerer.lowerExprExpecting(info.callableBase.expression, DYN);
+        const baseLocal = lowerer.declareHiddenLocal("%classBase", DYN);
+        const clsLocal = lowerer.declareHiddenLocal("%classValue", value.type);
+        const baseRef = { kind: "varRef", localId: baseLocal.id, type: DYN, loc };
+        const clsRef = { kind: "varRef", localId: clsLocal.id, type: value.type, loc };
+        const boxed = { kind: "dynFrom", value: clsRef, type: DYN, loc };
+        info.localPrototypeData = true;
+        return initializeRuntimeStatics(lowerer, info, { kind: "seqExpr", stmts: [
+                { kind: "varDecl", localId: baseLocal.id, init: base, loc },
+                { kind: "varDecl", localId: clsLocal.id, init: { ...value, captures: info.localClass.captureSources }, loc },
+                { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classInherit", args: [boxed, baseRef], type: DYN, loc }, loc },
+                { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classPrototype", args: [boxed,
+                            { kind: "libCall", fn: "dyn.classBasePrototype", args: [baseRef], type: DYN, loc },
+                        ], type: DYN, loc }, loc },
+            ], result: clsRef, type: value.type, loc });
+    }
     if (info.localClass?.baseExpression && info.base && value.kind === "classRef") {
         const loc = locOf(expr);
-        const base = lowerer.lowerExpr(info.localClass.baseExpression);
+        const base = lowerer.lowerExprExpecting(info.localClass.baseExpression, { kind: "classval", className: info.base.def.name });
         const baseLocal = lowerer.declareHiddenLocal("%classBase", base.type);
         baseLocal.boxed = true;
         const clsLocal = lowerer.declareHiddenLocal("%classValue", value.type);
@@ -3100,17 +3720,19 @@ export function lowerClassExpression(lowerer, expr) {
         const clsRef = { kind: "varRef", localId: clsLocal.id, type: value.type, loc };
         const basePrototype = classPrototypeData(lowerer, info.base, loc, baseRef);
         info.localPrototypeData = true;
-        return { kind: "seqExpr", stmts: [
+        return initializeRuntimeStatics(lowerer, info, { kind: "seqExpr", stmts: [
                 { kind: "varDecl", localId: baseLocal.id, init: base, loc },
                 { kind: "varDecl", localId: clsLocal.id, init: { ...value, captures: [...info.localClass.captureSources, baseLocal.id] }, loc },
+                { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classInherit", args: [
+                            { kind: "dynFrom", value: clsRef, type: DYN, loc }, { kind: "dynFrom", value: baseRef, type: DYN, loc },
+                        ], type: DYN, loc }, loc },
                 { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classPrototype", args: [
                             { kind: "dynFrom", value: clsRef, type: DYN, loc }, basePrototype,
                         ], type: DYN, loc }, loc },
-            ], result: clsRef, type: value.type, loc };
+            ], result: clsRef, type: value.type, loc });
     }
-    return info.localClass && value.kind === "classRef"
-        ? { ...value, captures: info.localClass.captureSources }
-        : value;
+    return info.localClass ? initializeRuntimeStatics(lowerer, info, value.kind === "classRef"
+        ? { ...value, captures: info.localClass.captureSources } : value) : value;
 }
 /** The EXACT class a receiver expression is statically known to BE (not
    * merely be typed by): the class name itself, or a `const` binding
@@ -3119,6 +3741,11 @@ export function lowerClassExpression(lowerer, expr) {
    * hit the declaring class's storage exactly (the shadowing hazards of
    * general class values don't arise). Null for everything else. */
 export function exactClassOfReceiver(lowerer, expr) {
+    if (ts.isPropertyAccessExpression(expr) && !expr.questionDotToken) {
+        const member = nsMemberIdentOf(lowerer, expr);
+        if (member)
+            return exactClassOfReceiver(lowerer, member);
+    }
     // A class-valued lexical this is introduced only for an exact static
     // receiver specialization; ordinary instance this remains an object.
     if (expr.kind === ts.SyntaxKind.ThisKeyword) {
@@ -3274,7 +3901,12 @@ 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)) {
-            const receiverType = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+            let receiverType = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+            if (receiverType?.kind !== "classval" && isJsSourceFile(call.getSourceFile())) {
+                const receiver = tryLowerExpression(lowerer, access.expression);
+                if (receiver?.type.kind === "classval")
+                    receiverType = receiver.type;
+            }
             if (receiverType?.kind !== "classval")
                 return null;
             const info = lowerer.classes.get(receiverType.className);
@@ -3331,6 +3963,10 @@ function classValueIsExactlyOwn(lowerer, recv, info) {
 }
 function staticCallOn(lowerer, call, access, info, throughValue) {
     const loc = locOf(call);
+    if (hasRuntimeStatics(info) && !findStaticOn(lowerer, info, access.name.text)?.field || info.callableBase && !findStaticOn(lowerer, info, access.name.text) && !findGenericStaticOn(lowerer, info, access.name.text))
+        return { kind: "dynInvoke", recv: lowerer.lowerExprExpecting(access.expression, DYN),
+            method: access.name.text, calleeName: access.name.text,
+            args: call.arguments.map((argument) => lowerer.lowerExprExpecting(argument, DYN)), type: DYN, loc };
     // #private statics: through-a-VALUE receiver the call devirtualizes
     // exactly when the value can only BE the declaring class
     // (classValueIsExactlyOwn — a slot that could hold a descendant at
@@ -3382,7 +4018,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
             }
             args.push(absent);
         }
-        return { kind: "callValue", callee, args, type: found.field.type.ret, loc };
+        return { kind: "callValue", callee, receiver: lowerer.lowerExprExpecting(access.expression, DYN), args, type: found.field.type.ret, loc };
     }
     if (found.method.member.body && hasStaticThis(found.method.member)) {
         const generic = found.method.receiverInfo ??= {
@@ -3435,6 +4071,10 @@ export function lowerClassValueProperty(lowerer, expr) {
         return null;
     const loc = locOf(expr);
     const member = expr.name.text;
+    const info = lowerer.classes.get(recvT.className);
+    if (info && (hasRuntimeStatics(info) && !findStaticOn(lowerer, info, member)?.field || info.callableBase && !findStaticOn(lowerer, info, member)))
+        return { kind: "dynKeyGet", value: lowerer.lowerExprExpecting(expr.expression, DYN),
+            key: { kind: "strLit", value: member, type: STRING, loc }, type: DYN, loc };
     // `X.name` reads the RUNTIME class object's stored name — the one
     // genuinely dynamic member. It CONSUMES the receiver (no evaluation
     // is discarded), so any receiver expression is fine here.
@@ -3444,6 +4084,8 @@ export function lowerClassValueProperty(lowerer, expr) {
             return null;
         return { kind: "libCall", fn: "class.name", args: [recv], type: STRING, loc };
     }
+    if (!info)
+        return null;
     if (!ts.isIdentifier(expr.expression) &&
         expr.expression.kind !== ts.SyntaxKind.ThisKeyword &&
         // `module.exports.label` in a class-replaced CJS module: the
@@ -3457,9 +4099,6 @@ export function lowerClassValueProperty(lowerer, expr) {
     }
     // The direct class-name spelling resolved in lowerStaticFieldRead;
     // reaching here means the receiver is a classval-typed BINDING.
-    const info = lowerer.classes.get(recvT.className);
-    if (!info)
-        return null;
     const found = findStaticOn(lowerer, info, member);
     if (!found) {
         lowerer.unsupported("SC1090", expr, `the static member '${member}' of class '${info.def.name.replace(/^%|^%m\d+\./, "")}' (static accessors and initializer-less static fields have no lowering, and Function members like .call/.bind/.prototype have no value form)`);
@@ -3554,15 +4193,153 @@ export function findGenericMethodOn(lowerer, info, name) {
 export function genericOverrideBelow(lowerer, info, name) {
     return info.subclasses.some((s) => s.genericMethods?.has(name) === true || genericOverrideBelow(lowerer, s, name));
 }
+/** Discover inherited data writes before any base storage ABI is chosen.
+ * The checker does not widen a base field for assignments in JS subclasses. */
+export function collectInheritedJsFieldWrites(lowerer, files) {
+    for (const file of files) {
+        if (!isJsSourceFile(file))
+            continue;
+        ts.walkPreorder(file, (node) => {
+            if ((!ts.isClassDeclaration(node) && !ts.isClassExpression(node)) || !node.heritageClauses?.length)
+                return;
+            const writes = new Map();
+            const addWrite = (name, expression) => {
+                const existing = writes.get(name);
+                if (existing)
+                    existing.push(expression);
+                else
+                    writes.set(name, [expression]);
+            };
+            const scan = (part) => {
+                if (ts.isClassDeclaration(part) || ts.isClassExpression(part) ||
+                    ts.isFunctionLike(part) && !ts.isArrowFunction(part))
+                    return;
+                if (ts.isBinaryExpression(part) && part.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                    const left = part.left;
+                    if (ts.isPropertyAccessExpression(left) && left.expression.kind === ts.SyntaxKind.ThisKeyword)
+                        addWrite(left.name.text, part.right);
+                    else if (ts.isElementAccessExpression(left) && left.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                        const name = lowerer.foldedStringKeyOf(left.argumentExpression);
+                        if (name !== null)
+                            addWrite(name, part.right);
+                    }
+                }
+                part.forEachChild(scan);
+            };
+            for (const member of node.members) {
+                if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))
+                    continue;
+                if (ts.isPropertyDeclaration(member) && member.initializer) {
+                    const name = ts.isPrivateIdentifier(member.name) ? null : classMemberNameOf(lowerer, member.name);
+                    if (name !== null)
+                        addWrite(name, member.initializer);
+                    scan(member.initializer);
+                }
+                if (ts.isConstructorDeclaration(member) || ts.isMethodDeclaration(member) || ts.isAccessor(member)) {
+                    if (member.body)
+                        scan(member.body);
+                }
+            }
+            if (writes.size === 0)
+                return;
+            const symbol = lowerer.typeOf(node).getSymbol();
+            const instance = symbol ? lowerer.checker.getDeclaredTypeOfSymbol(symbol) : null;
+            const seen = new Set();
+            const markBases = (type) => {
+                const target = type.isTypeReference() ? type.getTarget() : type;
+                if (!target?.isClassOrInterface() || seen.has(target))
+                    return;
+                seen.add(target);
+                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) : []) {
+                            if (ts.isMethodDeclaration(declaration) || ts.isAccessor(declaration))
+                                continue;
+                            let owner = declaration.parent;
+                            while (owner && !ts.isClassDeclaration(owner) && !ts.isClassExpression(owner))
+                                owner = owner.parent;
+                            if (!owner || (!ts.isClassDeclaration(owner) && !ts.isClassExpression(owner)) || !isJsSourceFile(owner.getSourceFile()))
+                                continue;
+                            let fields = lowerer.inheritedJsFieldWrites.get(owner);
+                            if (!fields)
+                                lowerer.inheritedJsFieldWrites.set(owner, fields = new Map());
+                            const existing = fields.get(name);
+                            if (existing)
+                                existing.push(...expressions);
+                            else
+                                fields.set(name, [...expressions]);
+                        }
+                    }
+                    markBases(base);
+                }
+            };
+            if (instance)
+                markBases(instance);
+        });
+    }
+}
 /** Discover overrides before choosing inferred method ABIs. Class collection
  * visits bases first, including imported bases and class expressions, so the
  * collected subclass graph cannot answer this question yet. The checker
  * hierarchy identifies the original declarations through aliases as well. */
 export function collectVirtualJsMethods(lowerer, files) {
-    if (!files.some(isJsSourceFile))
-        return;
+    const families = [];
+    // Record named prototype accesses before collecting method signatures.
+    // Those slots need a callable ABI even when JavaScript would otherwise
+    // specialize each call independently.
+    for (const file of files)
+        ts.walkPreorder(file, (node) => {
+            if (!ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
+                return;
+            const name = ts.isPropertyAccessExpression(node) ? node.name.text
+                : ts.isStringLiteralLike(node.argumentExpression) ? node.argumentExpression.text : null;
+            if (name === null)
+                return;
+            const prototype = ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "prototype";
+            const assigned = ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
+            const symbol = !assigned ? undefined : ts.isPropertyAccessExpression(node)
+                ? lowerer.checker.getSymbolAtLocation(node.name)
+                : lowerer.checker.getPropertyOfType(lowerer.typeOf(node.expression), name);
+            if (prototype || symbol && lowerer.checker.declarationsOf(symbol).some(ts.isMethodDeclaration)) {
+                lowerer.prototypeMethodAccesses.set(name, node);
+            }
+        });
     const visit = (node) => {
         if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+            const accessors = node.members.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 && accessors.length && isJsSourceFile(node.getSourceFile())) {
+                const symbol = lowerer.typeOf(node).getSymbol();
+                const instance = symbol ? lowerer.checker.getDeclaredTypeOfSymbol(symbol) : null;
+                const seen = new Set();
+                const markAccessors = (type) => {
+                    const target = type.isTypeReference() ? type.getTarget() : type;
+                    if (!target?.isClassOrInterface() || seen.has(target))
+                        return;
+                    seen.add(target);
+                    for (const base of lowerer.checker.getBaseTypes(target)) {
+                        for (const member of accessors) {
+                            if (!ts.isIdentifier(member.name))
+                                continue;
+                            const property = lowerer.checker.getPropertyOfType(base, member.name.text);
+                            for (const declaration of property ? lowerer.checker.declarationsOf(property) : []) {
+                                if ((ts.isGetAccessorDeclaration(declaration) || ts.isSetAccessorDeclaration(declaration)) && isJsSourceFile(declaration.getSourceFile())) {
+                                    lowerer.checkedVirtualJsAccessors.add(declaration);
+                                    lowerer.checkedVirtualJsAccessors.add(member);
+                                    for (const twin of node.members)
+                                        if ((ts.isGetAccessorDeclaration(twin) || ts.isSetAccessorDeclaration(twin)) &&
+                                            ts.isIdentifier(twin.name) && twin.name.text === member.name.text)
+                                            lowerer.checkedVirtualJsAccessors.add(twin);
+                                }
+                            }
+                        }
+                        markAccessors(base);
+                    }
+                };
+                if (instance)
+                    markAccessors(instance);
+            }
             const members = node.members.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) {
@@ -3585,8 +4362,17 @@ export function collectVirtualJsMethods(lowerer, files) {
                                     if (isJsSourceFile(member.getSourceFile()) && !member.typeParameters &&
                                         !member.asteriskToken && !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
                                         !bodyReadsArguments(member) &&
-                                        member.parameters.every((p) => !p.initializer && !p.dotDotDotToken)) {
+                                        member.parameters.every((p) => !p.dotDotDotToken)) {
                                         lowerer.virtualJsMethodArity.set(declaration, Math.max(lowerer.virtualJsMethodArity.get(declaration) ?? 0, member.parameters.length));
+                                        const checked = !declaration.typeParameters && !declaration.asteriskToken &&
+                                            !declaration.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
+                                            !bodyReadsArguments(declaration) &&
+                                            [...member.parameters, ...declaration.parameters].every((p) => !p.dotDotDotToken);
+                                        if (checked) {
+                                            lowerer.checkedVirtualJsMethods.add(declaration);
+                                            lowerer.checkedVirtualJsMethods.add(member);
+                                            families.push([declaration, member]);
+                                        }
                                     }
                                 }
                             }
@@ -3601,6 +4387,29 @@ export function collectVirtualJsMethods(lowerer, files) {
     };
     for (const file of files)
         ts.walkPreorder(file, visit);
+    for (const member of lowerer.checkedVirtualJsMethods) {
+        const scan = (node) => {
+            if (node !== member && ts.isFunctionLike(node))
+                return;
+            if (ts.isReturnStatement(node) && node.expression)
+                lowerer.checkedVirtualJsValueReturns.add(member);
+            node.forEachChild(scan);
+        };
+        scan(member);
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [base, derived] of families) {
+            if (!lowerer.checkedVirtualJsValueReturns.has(base) && !lowerer.checkedVirtualJsValueReturns.has(derived))
+                continue;
+            for (const member of [base, derived])
+                if (!lowerer.checkedVirtualJsValueReturns.has(member)) {
+                    lowerer.checkedVirtualJsValueReturns.add(member);
+                    changed = true;
+                }
+        }
+    }
 }
 /** The receiver's EXACT runtime class, when the expression proves it: a
    * `new C(...)` expression directly, or a const binding initialized with
@@ -3786,12 +4595,22 @@ export function lowerClassMembers(lowerer, info) {
     // signature-blocked function (lowerStaticMethod's rule) instead of
     // crashing the whole lowering.
     if (!info.generic && (always || lowerer.wantBody(`%${className}.constructor`))) {
+        const diagsBefore = lowerer.diags.length;
         try {
             out.push(lowerer.lowerClassCtor(info));
         }
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
+            if (info.decl && isJsSourceFile(info.decl.getSourceFile())) {
+                const types = [{ kind: "object", className }, ...info.ctorParams.map((param) => param.type)];
+                const fallback = lowerer.deferToRuntimeFence(diagsBefore, info.ctor ?? info.decl, {
+                    kind: "function", name: `%${className}.constructor`, returnType: VOID,
+                    params: types.map((type, index) => ({ localId: `p.${index}`, name: index === 0 ? "this" : `p${index}`, type })),
+                });
+                if (fallback)
+                    out.push(fallback);
+            }
         }
     }
     for (const { mName, member } of lowerer.classMethodMembers(info)) {
@@ -3877,6 +4696,11 @@ function lowerClassCtorInner(lowerer, info) {
             // defaults on entry, ahead of everything the body does.
             const declared = lowerer.declareParams(info.ctor.parameters, info.ctorParams);
             params.push(...declared.params);
+            if (info.ctorParams.at(-1)?.mode === "arguments") {
+                const local = lowerer.declareHiddenLocal("%arguments", DYN);
+                params.push({ localId: local.id, name: local.name, type: DYN });
+                lowerer.ctx.argumentsLocal = local;
+            }
             body.push(...declared.prologue);
             if (!ctorBase && !info.callableBase) {
                 // Node's base-class order: field initializers run at the start
@@ -3945,6 +4769,10 @@ function lowerClassCtorInner(lowerer, info) {
 export function classMemberNameOf(lowerer, name) {
     if (ts.isIdentifier(name))
         return name.text;
+    if (ts.isStringLiteralLike(name))
+        return name.text;
+    if (ts.isNumericLiteral(name))
+        return String(Number(name.text));
     // #private methods key by their spelled name ('#m') — '#' is
     // unspellable in public identifiers, the accessor-colon precedent.
     if (ts.isPrivateIdentifier(name))
@@ -4174,7 +5002,7 @@ export function lowerClassMethodMember(lowerer, info, fnLike) {
 function lowerClassMethodMemberInner(lowerer, info, fnLike) {
     const className = info.def.name;
     const thisType = { kind: "object", className };
-    const memberName = ts.isMethodDeclaration(fnLike) ? classMemberNameOf(lowerer, fnLike.name) : ts.isIdentifier(fnLike.name) || ts.isPrivateIdentifier(fnLike.name) ? fnLike.name.text : null;
+    const memberName = classMemberNameOf(lowerer, fnLike.name);
     if (memberName === null)
         return null;
     const mName = ts.isMethodDeclaration(fnLike)
@@ -4383,6 +5211,13 @@ export function fieldInitStmts(lowerer, info, thisLocal) {
     const out = [];
     const thisType = { kind: "object", className: info.def.name };
     for (const f of info.fieldOrder) {
+        if (f.errorCause) {
+            const loc = f.initializer ? locOf(f.initializer) : f.undefinedInitializer;
+            const value = f.initializer ? lowerer.lowerExprExpecting(f.initializer, DYN) : dynUndefinedExpr(loc);
+            out.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "error.defineCause",
+                    args: [{ kind: "varRef", localId: thisLocal.id, type: thisType, loc }, value], type: VOID, loc }, loc });
+            continue;
+        }
         if (f.undefinedInitializer) {
             const loc = f.undefinedInitializer;
             out.push({
@@ -4455,100 +5290,93 @@ function paramPropInitStmts(lowerer, info, thisLocal) {
     }
     return out;
 }
-/** A derived constructor's body: statements lower as usual EXCEPT the
-   * top-level `super(...)` statement, which becomes a direct call to the
-   * base constructor over the same `this`, immediately followed by this
-   * class's field initializers (JS runs them when super returns). tsc
-   * guarantees a super call exists and runs before any this-use; the
-   * supported form is a top-level expression statement — anywhere else
-   * (conditionals, expression positions) is rejected, not misordered. */
-export function lowerDerivedCtorBody(lowerer, info, thisLocal, 
-/** Mixin forwarding-constructor mode: `super(...args)` forwards these
- * pre-declared synthetic params directly (the spread never lowers —
- * the base's ABI is this constructor's ABI). */
-forward) {
-    const out = [];
+/** 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. */
+export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
     let superSeen = false;
-    const statements = info.ctor.body.statements;
-    const entry = { stmts: statements, index: 0, ctx: lowerer.ctx, frame: lowerer.scopes[lowerer.scopes.length - 1], out };
-    lowerer.activeStmtLists.push(entry);
-    try {
-        for (let index = 0; index < statements.length; index++) {
-            entry.index = index;
-            const stmt = statements[index];
-            const superCall = ts.isExpressionStatement(stmt) &&
-                ts.isCallExpression(stmt.expression) &&
-                stmt.expression.expression.kind === ts.SyntaxKind.SuperKeyword
-                ? stmt.expression
-                : null;
-            if (!superCall) {
-                out.push(...lowerer.lowerStmts([stmt]));
-                continue;
-            }
-            if (!lowerer.suppressStats) {
-                lowerer.stats.statementsTotal++;
-                lowerer.bumpFileStat(locOf(stmt).file, "total");
+    const initialized = lowerer.declareHiddenLocal("%superInitialized", BOOL);
+    initialized.mutable = true;
+    const context = lowerer.ctx;
+    const previous = context.superCall;
+    const previousInitialized = context.superInitialized;
+    context.superInitialized = initialized;
+    context.superCall = (superCall) => {
+        if (!ts.isExpressionStatement(superCall.parent))
+            lowerer.unsupported("SC1090", superCall, "super() in an expression position");
+        superSeen = true;
+        const loc = locOf(superCall);
+        const statements = [{ kind: "if", cond: { kind: "varRef", localId: initialized.id, type: BOOL, loc }, then: [{ kind: "exprStmt", expr: nodeThrowExpr(0, "SC2020", "repeated super() calls require a fresh receiver and are not supported yet", DYN, loc), loc }], else_: null, loc }];
+        if (info.callableBase) {
+            if (superCall.arguments.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)), type: DYN, loc };
+            statements.push(lowerer.superCallStmt(info, thisLocal, [pack], loc));
+        }
+        else {
+            const base = superBaseOf(info);
+            if (base.builtinEmitter && superCall.arguments.length > 0)
+                lowerer.unsupported("SC1090", superCall, "EventEmitter constructor options ('captureRejections')");
+            if (base.builtinStream) {
+                statements.push(...lowerStreamSuperCall(lowerer, info, base, superCall.arguments, thisLocal, loc, superCall));
             }
-            try {
-                if (superSeen)
-                    lowerer.unsupported("SC1090", stmt, "multiple super() calls");
-                superSeen = true;
-                if (info.callableBase) {
-                    if (superCall.arguments.some(ts.isSpreadElement))
-                        lowerer.unsupported("SC1090", superCall, "spreading explicit super arguments into an ordinary constructor");
-                    const loc = locOf(stmt);
-                    const pack = { kind: "dynArrLit", elems: superCall.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc };
-                    out.push(lowerer.superCallStmt(info, thisLocal, [pack], loc));
-                    out.push(...lowerer.fieldInitStmts(info, thisLocal));
-                    out.push(...paramPropInitStmts(lowerer, info, thisLocal));
-                    continue;
-                }
-                const base = superBaseOf(info);
-                if (base.builtinEmitter && superCall.arguments.length > 0) {
-                    // @types/node admits super({ captureRejections }) — no lowering.
-                    lowerer.unsupported("SC1090", superCall, "EventEmitter constructor options ('captureRejections')");
-                }
-                if (base.builtinStream) {
-                    // super(options?) into a runtime stream base: the stream spoke
-                    // parses the options and binds overridden underscore methods.
-                    out.push(...lowerStreamSuperCall(lowerer, info, base, superCall.arguments, thisLocal, locOf(stmt), stmt));
-                    out.push(...lowerer.fieldInitStmts(info, thisLocal));
-                    out.push(...paramPropInitStmts(lowerer, info, thisLocal));
-                    continue;
+            else {
+                const surplusSpread = forward === undefined && !base.builtinError && !base.builtinEmitter &&
+                    base.ctorParams.length === 0 && superCall.arguments.some(ts.isSpreadElement);
+                if (surplusSpread) {
+                    const evaluated = lowerer.completeArgs(superCall.arguments, [{ mode: "dynRest", type: DYN }], loc, superCall);
+                    for (const value of evaluated)
+                        statements.push({ kind: "exprStmt", expr: value, loc });
                 }
-                const args = forward !== undefined
-                    ? forward
-                    : base.builtinError
-                        ? lowerer.errorConstructorArgs(superCall.arguments, locOf(stmt), stmt)
-                        : base.builtinEmitter
-                            ? []
-                            : lowerer.completeArgs(superCall.arguments, base.ctorParams, locOf(stmt), stmt);
-                out.push(lowerer.superCallStmt(info, thisLocal, args, locOf(stmt)));
-                // super() returns → field initializers → parameter-property
-                // assignments (Node's order, probed) → the rest of the body.
-                out.push(...lowerer.fieldInitStmts(info, thisLocal));
-                out.push(...paramPropInitStmts(lowerer, info, thisLocal));
-            }
-            catch (e) {
-                if (!(e instanceof PoisonError))
-                    throw e;
-                if (!lowerer.suppressStats) {
-                    lowerer.stats.statementsFailed++;
-                    lowerer.bumpFileStat(locOf(stmt).file, "failed");
+                const surplus = forward === undefined && !base.builtinError && !base.builtinEmitter &&
+                    !base.ctorParams.some((param) => param.mode === "rest" || param.mode === "dynRest" || param.mode === "islandRest") &&
+                    !superCall.arguments.some(ts.isSpreadElement) && superCall.arguments.length > base.ctorParams.length;
+                let args = surplusSpread ? [] : forward !== undefined ? forward : base.builtinError
+                    ? lowerer.errorConstructorArgs(superCall.arguments, loc, superCall) : base.builtinEmitter ? []
+                    : lowerer.completeArgs(surplus ? superCall.arguments.slice(0, base.ctorParams.length) : superCall.arguments, 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)) {
+                        statements.push({ kind: "exprStmt", expr: lowerer.lowerExpr(argument), loc: locOf(argument) });
+                    }
                 }
+                statements.push(lowerer.superCallStmt(info, thisLocal, args, loc));
             }
         }
+        statements.push({ kind: "assign", localId: initialized.id, value: { kind: "boolLit", value: true, type: BOOL, loc }, loc });
+        delete context.superInitialized;
+        try {
+            statements.push(...lowerer.fieldInitStmts(info, thisLocal), ...paramPropInitStmts(lowerer, info, thisLocal));
+        }
+        finally {
+            context.superInitialized = initialized;
+        }
+        const result = { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc };
+        return { kind: "seqExpr", stmts: statements.map((statement) => statement.kind === "runtimeFence"
+                ? { kind: "exprStmt", expr: nodeThrowExpr(0, statement.code, statement.message, DYN, statement.loc), loc: statement.loc }
+                : statement), result, type: result.type, loc };
+    };
+    try {
+        const result = lowerer.lowerStmts(info.ctor.body.statements);
+        result.push({ kind: "if", cond: { kind: "unary", op: "!", operand: { kind: "varRef", localId: initialized.id, type: BOOL, loc: locOf(info.ctor) }, type: BOOL, loc: locOf(info.ctor) }, then: [{ kind: "exprStmt", expr: nodeThrowExpr(5, "", "Must call super constructor in derived class before accessing 'this' or returning from derived constructor", DYN, locOf(info.ctor)), loc: locOf(info.ctor) }], else_: null, loc: locOf(info.ctor) });
+        if (!superSeen)
+            lowerer.pushDiag(unsupportedDiag("SC1090", locOf(info.ctor), "derived constructors without a lowered super() call"));
+        return [{ kind: "varDecl", localId: initialized.id, init: { kind: "boolLit", value: false, type: BOOL, loc: locOf(info.ctor) }, loc: locOf(info.ctor) }, ...result];
     }
     finally {
-        lowerer.activeStmtLists.pop();
-    }
-    if (!superSeen) {
-        // tsc guarantees the call exists somewhere; if it wasn't a top-level
-        // statement the per-site rejection above already fired — this is the
-        // constructor-level backstop so a half-initialized ctor never emits.
-        lowerer.pushDiag(unsupportedDiag("SC1090", locOf(info.ctor), "super() calls anywhere but as a top-level constructor statement"));
+        if (previous)
+            context.superCall = previous;
+        else
+            delete context.superCall;
+        if (previousInitialized)
+            context.superInitialized = previousInitialized;
+        else
+            delete context.superInitialized;
     }
-    return out;
 }
 /** `super(args)` → direct call of the base constructor with the SAME
    * `this` (upcast; retained by the varRef read — the callee owns and
@@ -4564,7 +5392,10 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
     if (info.callableBase)
         return {
             kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classSuper",
-                args: [{ kind: "varRef", localId: info.callableBase.constructorId, type: DYN, loc },
+                args: [info.localClass ? { kind: "libCall", fn: "dyn.getPrototype", args: [
+                            { kind: "dynFrom", value: { kind: "fieldGet", obj: thisRef, className: info.def.name,
+                                    field: `%classEnvironment:${info.def.name}`, type: { kind: "classval", className: info.def.name }, loc }, type: DYN, loc },
+                        ], type: DYN, loc } : { kind: "varRef", localId: info.callableBase.constructorId, type: DYN, loc },
                     lowerer.coerceToExpected(thisRef, DYN), args[0]], type: VOID, loc }, loc,
         };
     if (base.builtinError) {
@@ -4682,6 +5513,16 @@ export function lowerSuperMethodCall(lowerer, call, access) {
         lowerer.unsupported("SC1080", access);
     const loc = locOf(call);
     const thisRef = { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc };
+    if (lowerer.prototypeMethodAccesses.has(access.name.text)) {
+        const prototype = classPrototypeData(lowerer, cls.base, loc);
+        if (prototype) {
+            const callee = { kind: "dynKeyGet", value: prototype,
+                key: { kind: "strLit", value: access.name.text, type: STRING, loc }, type: DYN, loc };
+            const value = { kind: "dynCall", callee, receiver: lowerer.coerceToExpected(thisRef, DYN),
+                calleeName: access.getText(), args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc };
+            return found.sig.ret.kind === "void" ? value : lowerer.coerceToExpected(value, found.sig.ret);
+        }
+    }
     if (found.declarer.builtinError) {
         return { kind: "libCall", fn: "error.toString", args: [lowerer.upcastTo(thisRef, "%Error")], type: STRING, loc };
     }
@@ -4865,6 +5706,11 @@ function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
     const args = lowerer.inheritsBuiltinErrorCtor(info)
         ? lowerer.errorConstructorArgs(expr.arguments ?? [], loc, expr)
         : lowerer.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
+    for (let current = info; current; current = current.base) {
+        if (current.def.baseValueGlobal)
+            return { kind: "newValue", callee: classValueRef(lowerer, info, expr),
+                args, type: { kind: "object", className: info.def.name }, loc };
+    }
     return {
         kind: "new",
         className: info.def.name,
@@ -4886,12 +5732,32 @@ function assignedThisFieldType(lowerer, expr) {
 }
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    let intlConstructor = expr.expression;
+    if (ts.isIdentifier(intlConstructor)) {
+        const symbol = lowerer.resolveValueSymbol(intlConstructor);
+        const declaration = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+        if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer)
+            intlConstructor = declaration.initializer;
+    }
+    const intl = ts.isPropertyAccessExpression(intlConstructor) ? lowerer.stdlibGlobalMember(intlConstructor, "Intl") : null;
+    if (intl && intl !== "Segmenter")
+        lowerer.noLowering(`new Intl.${intl}`, expr, undefined, lowerer.checker.getSymbolAtLocation(expr.expression));
     const instanceConstructor = lowerInstanceConstructorNew(lowerer, expr);
     if (instanceConstructor)
         return instanceConstructor;
     const objectFactory = lowerObjectFactoryNew(lowerer, expr);
     if (objectFactory)
         return objectFactory;
+    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);
+        if (declaration && ts.isFunctionDeclaration(declaration) && declaration.body) {
+            const last = declaration.body.statements.at(-1);
+            if (last && ts.isReturnStatement(last) && last.expression && ts.isObjectLiteralExpression(last.expression)) {
+                lowerer.unsupported("SC1090", expr, "object-returning constructors that observe this or return mixed primitive/object values");
+            }
+        }
+    }
     let selected = expr.expression;
     while (ts.isParenthesizedExpression(selected))
         selected = selected.expression;
@@ -5004,9 +5870,11 @@ export function lowerNew(lowerer, expr) {
             if (info?.classDecorators?.valueGlobalId !== undefined) {
                 lowerer.unsupported("SC1090", expr, "constructing a decorated class through a qualified name (a replacing decorator rebinds the class name — construct through the bare name)");
             }
-            if (info)
+            if (info && !info.localClass)
                 return lowerProgramClassNew(lowerer, expr, info, loc);
-            lowerer.unsupported("SC1090", expr, `constructing '${expr.expression.name.text}' (a namespace member with no class lowering)`);
+            // A namespace export can hold a class returned by a factory.
+            // Let the class-value path below preserve that constructor's
+            // lexical environment instead of requiring a class declaration.
         }
         // `new B.C()` where B is an AMBIENT namespace (fundule merges
         // included): Node evaluates the callee first and throws
@@ -5092,11 +5960,17 @@ export function lowerNew(lowerer, expr) {
         if (agent)
             return agent;
     }
-    if (ts.isIdentifier(expr.expression)) {
+    if (ts.isIdentifier(expr.expression) || ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.name) &&
+        lowerer.isStdlibGlobal(expr.expression.expression, "globalThis")) {
         // `import C = N.C; new C()` — the alias's own source-order guards
         // (a no-op for every non-import= binding).
-        fenceEarlyAliasUse(lowerer, expr.expression, expr);
-        const symbol = lowerer.resolveValueSymbol(expr.expression);
+        if (ts.isIdentifier(expr.expression))
+            fenceEarlyAliasUse(lowerer, expr.expression, 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 ?? []);
+        }
         if (isNativeProxyInitializer(lowerer, expr))
             return lowerNativeProxy(lowerer, expr);
         // `new Error(msg?)` and its standard subclasses: the
@@ -5307,20 +6181,10 @@ 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.
-        // `new Object()` — the spec's OrdinaryObjectCreate, exactly what the
-        // `{}` literal builds (fresh reference identity, no own properties) —
-        // lowers as the empty record. The ARGUMENT form is Object(x): it
-        // returns its argument for objects and BOXES primitives — the wrapper
-        // story with no lowering — so it keeps the constructor fence.
-        if (symbol?.name === "Object" &&
-            lowerer.isStdlibSymbol(symbol) &&
-            (expr.arguments ?? []).length === 0) {
-            return {
-                kind: "recordLit",
-                fields: [],
-                type: { kind: "record", shapeId: lowerer.shapes.intern([]) },
-                loc,
-            };
+        if (symbol?.name === "Object" && lowerer.isStdlibSymbol(symbol)) {
+            const object = lowerObjectConstructor(lowerer, expr.arguments ?? [], loc);
+            if (object)
+                return object;
         }
         if (symbol?.name === "Array" && lowerer.isStdlibSymbol(symbol)) {
             return lowerArrayConstructor(lowerer, expr, expr.arguments ?? []);
@@ -5440,6 +6304,10 @@ export function lowerNew(lowerer, expr) {
                 if (seeded)
                     return seeded;
             }
+            if (!mapped && isJsSourceFile(expr.getSourceFile()) && (expr.arguments?.length ?? 0) <= 1 && !expr.arguments?.some(ts.isSpreadElement)) {
+                return { kind: "libCall", fn: "dyn.nativeSetNew", args: [expr.arguments?.[0]
+                            ? lowerer.lowerExprExpecting(expr.arguments[0], DYN) : dynUndefinedExpr(loc)], type: DYN, loc };
+            }
             // JavaScript's identity-Set idiom: `new Set([setTimeout, atob,
             // ...])` — the element TYPE (a union of stdlib signatures) has no
             // mapping, but the element VALUES all lower to identity tokens
@@ -5583,7 +6451,7 @@ export function lowerNew(lowerer, expr) {
                 Proxy: "native Proxy construction requires checked-native plain targets and handlers",
                 Function: "runtime code generation cannot be compiled ahead of time (the eval stance) — write the function",
             };
-            lowerer.noLowering(`new ${expr.expression.text}`, expr, ctorHints[expr.expression.text], symbol);
+            lowerer.noLowering(`new ${expr.expression.text}`, expr, ctorHints[ts.isIdentifier(expr.expression) ? expr.expression.text : expr.expression.name.text], symbol);
         }
     }
     // `new crypto.X509Certificate(data)` — the Dirent-style data record:
@@ -5696,6 +6564,8 @@ export function lowerNew(lowerer, expr) {
                 lowerer.unsupported("SC1090", expr, "constructing through a class value of an uninstantiated generic type (annotate the slot with a concrete instantiation — e.g. 'new (v: number) => Box<number>')");
             }
             const callee = lowerer.lowerExpr(expr.expression);
+            if (callee.type.kind === "dyn")
+                return lowerCheckedConstructor(lowerer, expr, callee);
             if (callee.type.kind !== "classval")
                 lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
             lowerer.noteEdge(`%${info.def.name}.constructor`);
@@ -5720,6 +6590,10 @@ export function lowerNew(lowerer, expr) {
         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)) && lowerer.dynConvertible(calleeT)) {
+                    const callee = lowerer.lowerExprExpecting(expr.expression, DYN);
+                    return lowerCheckedConstructor(lowerer, expr, callee);
+                }
                 lowerer.unsupported("SC1090", expr, "constructing through a union of class values (annotate the slot with the common constructor type — e.g. `new () => Base` — or narrow first)");
             }
         }
@@ -5745,8 +6619,22 @@ export function lowerNew(lowerer, expr) {
             }
         }
     }
+    // Checked construction supports emitted classes and builtin typed arrays.
+    const callee = tryLowerExpression(lowerer, expr.expression);
+    if (callee && (callee.type.kind === "dyn" || (callee.type.kind === "func" || callee.type.kind === "classval") && lowerer.dynConvertible(callee.type))) {
+        return lowerCheckedConstructor(lowerer, expr, lowerer.coerceToExpected(callee, DYN));
+    }
     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 ?? [];
+    if (args.some(ts.isSpreadElement)) {
+        const packed = lowerer.completeArgs(args, [{ type: DYN, mode: "dynRest" }], loc, expr)[0];
+        return checkedClassConstructionPacked(lowerer, callee, packed, loc);
+    }
+    return checkedClassConstruction(lowerer, callee, args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
+}
 /** A getter/setter invocation over an accessor target's receiver — the
    * same whole-program devirtualization as method calls: a virtualCall
    * when some strict subclass of the receiver's static class overrides