@scriptc/compiler 0.2.0 → 0.2.1

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,13 @@ 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 } from "./class-construction.js";
+import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js";
 export function returnsOnlyThis(member) {
     const body = member.body;
     const last = body?.statements.at(-1);
@@ -58,11 +61,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 +83,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);
+            }
+        }
+    }
+    // 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 lowerer.mapTypeOf(lowerer.typeOf(expression));
+    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 +337,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 },
                 ],
@@ -340,6 +495,14 @@ function jsFieldInitializerType(lowerer, type, expression) {
     let node = expression;
     while (ts.isParenthesizedExpression(node))
         node = node.expression;
+    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);
@@ -803,12 +966,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 +1015,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 +1052,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 +1062,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 +1128,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 +1204,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 +1260,8 @@ mixin) {
         const staticFields = [];
         const staticMethods = new Map();
         const staticBlocks = [];
+        const runtimeStatics = [];
+        const runtimePrototypeMembers = [];
         // 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 +1310,18 @@ mixin) {
             });
         };
         for (const member of decl.members) {
+            if (functionLocalClass(decl) && 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
@@ -1175,7 +1371,8 @@ mixin) {
                     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 +1434,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 +1555,38 @@ 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;
+                    const 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);
                     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,6 +1635,12 @@ mixin) {
                 // as undefined on construction, verified), and reads/writes ride
                 // the ordinary undefined-armed union machinery.
                 let type = lowerer.irTypeOf(member.name);
+                // 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") {
@@ -1650,7 +1865,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 +1884,22 @@ mixin) {
                     }
                 }
                 const { shapes, funcType: ft } = lowerer.lambdaSignature(member);
+                // 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 +1935,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 &&
@@ -1748,7 +1985,18 @@ mixin) {
                         // 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)`));
@@ -1803,9 +2051,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 +2071,8 @@ 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) && !((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");
                 }
@@ -2073,18 +2330,29 @@ 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.unsupported("SC1090", lhs, "constructor-assigned fields shadowing methods");
+                        }
                         // 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 +2372,10 @@ 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 });
+                        fields.set(fieldName, type);
+                        if (key)
+                            symbolFields.set(key.identity, fieldName);
+                        fieldOrder.push({ name: fieldName, type, initializer: undefined });
                     }
                 }
             }
@@ -2197,7 +2466,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 ? { runtimeStatics } : {}),
+            ...(runtimePrototypeMembers.length ? { runtimePrototypeMembers } : {}),
             def: {
                 name: className,
                 // The JS-observable .name (the class object's name string and
@@ -2237,6 +2512,7 @@ mixin) {
             ...(paramProps.length > 0 ? { paramProps } : {}),
             base,
             ...(callableBase ? { callableBase } : {}),
+            ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
             throwingSetters,
             staticFields,
@@ -2297,7 +2573,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 +2771,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 +2800,38 @@ 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 });
     }
     const items = [
         ...info.staticFields.map((f) => ({ pos: f.initializer.getStart(), kind: "field", f })),
@@ -2523,12 +2849,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) {
@@ -2815,6 +3152,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,6 +3221,8 @@ 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)
@@ -2903,6 +3247,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,6 +3277,9 @@ 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 };
@@ -2987,13 +3337,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 +3388,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.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 +3408,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 +3433,11 @@ export function lowerClassExpression(lowerer, expr) {
         }
     }
     const info = lowerClassExpressionInfo(lowerer, expr);
+    if (!info.localClass && !info.expressionInitializationEmitted &&
+        (info.callableBase || info.def.baseValueGlobal || 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 +3453,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 +3461,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 +3489,20 @@ 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"
+    return initializeRuntimeStatics(lowerer, info, info.localClass && 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
@@ -3274,7 +3666,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()) && ts.isCallExpression(access.expression)) {
+                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 +3728,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 +3783,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 +3836,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 +3849,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 +3864,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)`);
@@ -3559,8 +3963,26 @@ export function genericOverrideBelow(lowerer, info, name) {
  * 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;
+    // 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 members = node.members.filter((member) => ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&
@@ -3786,12 +4208,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 +4309,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
@@ -4174,7 +4611,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 +4820,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 +4899,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 +5001,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 +5122,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 +5315,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,
@@ -4892,6 +5347,16 @@ export function lowerNew(lowerer, expr) {
     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 +5469,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 +5559,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 +5780,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 +5903,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 +6050,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 +6163,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 checkedClassConstruction(lowerer, callee, (expr.arguments ?? []).map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
             if (callee.type.kind !== "classval")
                 lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
             lowerer.noteEdge(`%${info.def.name}.constructor`);
@@ -5745,6 +6214,11 @@ 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" && lowerer.dynConvertible(callee.type)) && !(expr.arguments ?? []).some(ts.isSpreadElement)) {
+        return checkedClassConstruction(lowerer, lowerer.coerceToExpected(callee, DYN), (expr.arguments ?? []).map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
+    }
     lowerer.unsupported("SC1090", expr, "constructing values other than classes declared in the program");
 }
 /** A getter/setter invocation over an accessor target's receiver — the