@scriptc/compiler 0.1.7 → 0.2.1

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

@@ -5,25 +5,228 @@ import { InternalCompilerError } from "../../errors.js";
  * accessor access, upcasts, `new` expressions, and the builtin Error
  * 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, URL_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals } from "../../ir/ir.js";
-import { MAX_GENERIC_INSTANCES, appendImplicitUndefinedReturn, generatorMeta, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
-import { isGenericCallableMemberType, typeKey } from "../type-mapper.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, 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, lowerMapSeedArrayNew } 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 } from "./lower-builtins.js";
+import { lowerSearchParamsNew, lowerTextCodecNew } from "./lower-builtins.js";
 import { requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape } from "./lower-stream.js";
 import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall } from "./lower-event-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
-import { uniqueSymbolKeyOf } from "./lower-exprs.js";
+import { classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName } from "./symbol-fields.js";
+import { builtinFenceHintOf } from "./surfaces.js";
 import { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
-import { rejectStaticThis } from "./static-this.js";
-import { staticForkString } from "../fork-target.js";
+import { hasLexicalPrivateReference, hasStaticThis, rejectStaticThis } from "./static-this.js";
+import { lowerUrlNew } from "./lower-url.js";
+import { isNativeProxyInitializer, lowerNativeProxy } from "./expressions/native-proxy.js";
+import { classStaticDataFor } from "./class-static-data.js";
+import { 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);
+    if (!body || !last || !ts.isReturnStatement(last))
+        return false;
+    let valid = true;
+    const visit = (node) => {
+        if (ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node)) {
+            let value = node.expression;
+            while (value && ts.isParenthesizedExpression(value))
+                value = value.expression;
+            if (!value || value.kind !== ts.SyntaxKind.ThisKeyword)
+                valid = false;
+        }
+        node.forEachChild(visit);
+    };
+    body.forEachChild(visit);
+    return valid;
+}
+function functionLocalClass(decl) {
+    for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
+        if (ts.isFunctionLike(parent))
+            return true;
+    }
+    return false;
+}
+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, visiting);
+    }
+    if (expression.kind === ts.SyntaxKind.ThisKeyword) {
+        const stored = lowerer.resolveThis();
+        if (stored?.type.kind === "classval")
+            return stored.type;
+    }
+    if (ts.isIdentifier(expression)) {
+        const stored = lowerer.peekLocal(expression) ?? lowerer.globalOf(expression);
+        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 mapped;
+}
 /** The KEY symbol behind a LATE-BOUND (`__@name@id`) property: resolved
    * from the argument of the element-access assignment that declared it
    * (`this[kLimit] = v` — the declaration list holds the BinaryExpression
@@ -92,8 +295,8 @@ function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
             return null;
         if (e.expression.kind !== ts.SyntaxKind.ThisKeyword)
             return null;
-        const key = uniqueSymbolKeyOf(lowerer, e.argumentExpression);
-        const fieldName = key ? symbolFields.get(key.sym) : undefined;
+        const key = classSymbolKeyOf(lowerer, e.argumentExpression);
+        const fieldName = key ? symbolFields.get(key.identity) : undefined;
         const t = fieldName !== undefined ? fields.get(fieldName) : undefined;
         if (t === undefined || t.kind === "dyn")
             return null;
@@ -103,7 +306,7 @@ function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
     }
     return out;
 }
-/** The builtin Error hierarchy (Error + TypeError/RangeError/SyntaxError)
+/** The builtin Error hierarchy
    * as eagerly-registered ClassInfos: mapType names them the moment a lib
    * Error type appears, so the infos must exist before any lowering. They
    * are runtime-provided — no decl, no lowerable bodies; `new`/super()/
@@ -126,11 +329,20 @@ export function registerBuiltinErrorClasses(lowerer) {
                 // subclass declaring its own `code` field lays out AFTER it,
                 // never colliding), and it is NOT in the fields map below: the
                 // READ has its own `string | undefined` lowering (error.code),
-                // never a plain-string field access.
+                // never a plain-string field access. `%cause` is the following
+                // owned dyn slot; NULL means absent, dyn undefined means present.
                 fields: [
                     { name: "name", type: STRING },
                     { name: "message", type: STRING },
                     { 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 },
                 ],
                 loc,
             },
@@ -148,10 +360,9 @@ export function registerBuiltinErrorClasses(lowerer) {
             decl: null,
             builtinError: true,
             ctor: null,
-            // Display shape of `new Error(message?)`. Construction and super()
-            // never complete against this — errorMessageArg owns those (the
-            // runtime ABI is one plain string; "" when omitted, like Node).
-            ctorParams: [{ type: STRING, mode: "omittable" }],
+            // Inherited constructors forward both raw arguments. The runtime
+            // applies the undefined message default and InstallErrorCause.
+            ctorParams: [{ type: DYN, mode: "omittable" }, { type: DYN, mode: "omittable" }],
             base,
             subclasses: [],
             throwingSetters: [],
@@ -278,17 +489,64 @@ export function builtinStreamInfoOf(lowerer, symbol) {
     });
     return declared ? (lowerer.classes.get(irName) ?? null) : null;
 }
+/** 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) {
+    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);
+    for (const arm of inferred.isUnionType() ? ts.constituentTypes(inferred) : [inferred]) {
+        if ((arm.flags & ts.TypeFlags.Undefined) !== 0)
+            type = lowerer.withUndefinedArmOf(type) ?? type;
+        if ((arm.flags & ts.TypeFlags.Null) !== 0)
+            type = withUnitArm(type, "nullT", lowerer.unions) ?? type;
+    }
+    if (ts.isConditionalExpression(node)) {
+        return jsFieldInitializerType(lowerer, jsFieldInitializerType(lowerer, type, node.whenTrue), node.whenFalse);
+    }
+    if (ts.isBinaryExpression(node)) {
+        if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken)
+            type = jsFieldInitializerType(lowerer, type, node.left);
+        if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+            node.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+            node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)
+            return jsFieldInitializerType(lowerer, type, node.right);
+    }
+    return type;
+}
 /** 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
-   * inference is unmappable, checked-dynamic (dyn stays out of class
-   * fields — KEEP NARROW), or an arm-less kind that cannot join a union
+   * inference is unmappable or an arm-less kind that cannot join a union
    * (genResultRecord's list, including scalar-backed Date values). */
 function undefArmedFieldType(lowerer, p) {
     const t = lowerer.checker.getTypeOfSymbol(p);
-    const mapped = lowerer.mapTypeOf(t);
-    if (!mapped || mapped.kind === "void" || mapped.kind === "dyn")
+    const site = lowerer.checker.declarationsOf(p)[0];
+    let mapped = lowerer.mapTypeOf(t) ?? (site ? dynFallbackType(lowerer, site, t) : null);
+    if (mapped && site)
+        mapped = jsOpenObjectType(site, mapped, lowerer.shapes, lowerer.unions);
+    if (!mapped || mapped.kind === "void")
         return null;
+    for (const declaration of lowerer.checker.declarationsOf(p)) {
+        const assignment = ts.isBinaryExpression(declaration) ? declaration : declaration.parent;
+        if (assignment && ts.isBinaryExpression(assignment) && assignment.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            mapped = jsFieldInitializerType(lowerer, mapped, assignment.right);
+        }
+    }
+    // An implicit JS value already carries undefined in its native box.
+    if (mapped.kind === "dyn")
+        return mapped;
     const byKey = new Map();
     const arms = mapped.kind === "union" ? (lowerer.unions.get(mapped.unionId)?.arms ?? []) : [mapped];
     for (const a of arms) {
@@ -539,7 +797,7 @@ function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
         if (collection === "Map" && node.expression.name.text === "set" && node.arguments.length === 2) {
             const key = mappedArgument(node.arguments[0]);
             const value = mappedArgument(node.arguments[1]);
-            if (key !== null && value !== null && isSupportedMapKey(key) && isSupportedMapValue(value)) {
+            if (key !== null && value !== null && isSupportedMapKey(key, key.kind === "union" ? lowerer.unions.get(key.unionId)?.arms : undefined) && isSupportedMapValue(value)) {
                 mapKeys.push(key);
                 mapValues.push(value);
             }
@@ -548,7 +806,7 @@ function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
             (node.expression.name.text === "add" || node.expression.name.text === "has" || node.expression.name.text === "delete") &&
             node.arguments.length === 1) {
             const element = mappedArgument(node.arguments[0]);
-            if (element !== null && isSupportedSetElem(element))
+            if (element !== null && isSupportedSetElem(element, element.kind === "union" ? lowerer.unions.get(element.unionId)?.arms : undefined))
                 setElements.push(element);
         }
         return undefined;
@@ -708,7 +966,25 @@ 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 (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()) ||
+                !(ts.isFunctionDeclaration(source) || ts.isFunctionExpression(source)))
+                return false;
+            callableBase = { expression, constructorId: `%g.${className}.base`, prototypeId: `%g.${className}.basePrototype` };
+            return true;
+        };
         // A family whose `extends` clause mentions its OWN type parameters
         // (`class D<T> extends Box<T>`) would need a different base per
         // instantiation — no single family interval can sit above all of
@@ -739,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
@@ -754,6 +1030,14 @@ mixin) {
                 const resolved = memberSym && memberSym.flags & ts.SymbolFlags.Alias
                     ? lowerer.checker.getAliasedSymbol(memberSym)
                     : memberSym;
+                const globalError = !t.expression.questionDotToken && lowerer.isStdlibGlobal(t.expression.expression, "globalThis")
+                    ? lowerer.builtinErrorInfoOf(resolved) : null;
+                if (globalError && globalError.def.name !== "%DOMException") {
+                    if (t.typeArguments)
+                        lowerer.unsupported("SC1090", t, "extending generic classes");
+                    base = globalError;
+                    continue;
+                }
                 const emitterBase = lowerer.builtinEmitterInfoOf(resolved);
                 const streamBaseNs = builtinStreamInfoOf(lowerer, resolved);
                 if (emitterBase || streamBaseNs) {
@@ -768,14 +1052,18 @@ 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 nsBase = resolved ? lowerer.classBySymbol.get(resolved) : undefined;
+                    const stored = storedClassValueType(lowerer, t.expression);
+                    const nsBase = (resolved ? lowerer.classBySymbol.get(resolved) : undefined) ??
+                        (stored?.kind === "classval" ? lowerer.classes.get(stored.className) : undefined);
                     if (!nsBase) {
+                        if (adoptCallableBase(t.expression))
+                            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;
                 }
@@ -840,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);
@@ -880,7 +1177,11 @@ mixin) {
                 // A const BINDING of a mixin call (`const Tagged = M(Base);
                 // class D extends Tagged {}`): the binding pins that call's
                 // instantiation — collected on demand (lower-mixins.ts).
-                mixinResultBindingClassOf(lowerer, symbol) ?? null;
+                mixinResultBindingClassOf(lowerer, symbol) ??
+                (() => {
+                    const stored = storedClassValueType(lowerer, t.expression);
+                    return stored?.kind === "classval" ? lowerer.classes.get(stored.className) : null;
+                })() ?? null;
             // `extends Box<number>` — a GENERIC program class as the base: the
             // base is the concrete INSTANTIATION, resolved through the heritage
             // type (mapType registers/reuses `Box%0`).
@@ -898,13 +1199,43 @@ mixin) {
                 lowerer.unsupported("SC1090", t, "extending generic classes");
             base = named;
             if (!base) {
+                if (adoptCallableBase(t.expression))
+                    continue;
                 lowerer.unsupported("SC1090", t, `extending classes not declared in the program ('${t.expression.text}')`);
             }
         }
+        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) {
+                    lowerer.unsupported("SC1090", decl, "classes extending builtin bases as values (the inherited runtime constructor has no class-value adapter)");
+                }
+            }
+        }
         const fields = new Map(base ? base.fields : []);
-        const symbolFields = new Map(base?.symbolFields ?? []);
+        const errorRooted = (() => {
+            for (let c = base; c; c = c.base)
+                if (c.builtinError)
+                    return true;
+            return false;
+        })();
+        const symbolFields = new Map();
+        if (base?.symbolFields)
+            for (const [symbol, name] of base.symbolFields)
+                symbolFields.set(symbol, name);
+        const symbolMethods = new Map();
+        if (base?.symbolMethods)
+            for (const [symbol, name] of base.symbolMethods)
+                symbolMethods.set(symbol, name);
         const fieldOrder = [];
         const methods = new Map();
+        const methodEntryFences = new Map();
         // Own accessor declarations ("get:x"/"set:x" → node), for the
         // partial-override analysis below (diagnostics need the node).
         const accessorNodes = new Map();
@@ -929,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
@@ -977,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
@@ -1026,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") {
+                    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({
@@ -1043,10 +1389,22 @@ mixin) {
                 if (ts.isMethodDeclaration(member) &&
                     (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                     member.body &&
-                    member.typeParameters === undefined &&
-                    member.asteriskToken === undefined) {
+                    member.typeParameters === undefined) {
                     const { shapes, funcType: ft } = lowerer.lambdaSignature(member);
+                    if (member.asteriskToken !== undefined && ft.ret.kind !== "generator") {
+                        lowerer.badType(member.name, lowerer.typeOf(member.name));
+                    }
                     staticMethods.set(member.name.text, { params: shapes, ret: ft.ret, member });
+                    if (implicitMonoFile(decl.getSourceFile()) && !functionLocalClass(decl) &&
+                        inst === undefined && decl.typeParameters === undefined) {
+                        const implicit = implicitAnyParamSymbolsOf(lowerer, member, true);
+                        if (implicit)
+                            genericStatics.set(member.name.text, {
+                                decl: member, baseName: member.name.text,
+                                qualifiedName: `%${className}.static:${member.name.text}%implicit`,
+                                typeParams: [], instances: new Map(), implicitParams: implicit,
+                            });
+                    }
                 }
                 // GENERIC static methods monomorphize like top-level generic
                 // functions (`%C.static:m%n`), async ones included — a generic
@@ -1075,6 +1433,16 @@ mixin) {
             // 7's ClassElement base carries no `name`; read it structurally
             // (every named member kind stores a PropertyName there).
             const memberName = member.name;
+            if (errorRooted && memberName && classMemberNameOf(lowerer, memberName) === "cause") {
+                if (ts.isPropertyDeclaration(member) && !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
+                    if (!isJsSourceFile(member.getSourceFile()))
+                        lowerer.unsupported("SC1090", memberName, "redeclaring Error.cause (pass the cause in the Error constructor options)");
+                    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
             // maps collision-free — with the base-chain walks doubling as
@@ -1187,6 +1555,40 @@ mixin) {
                     // get/set pair — declare the field and accessors explicitly.
                     lowerer.unsupported("SC1090", member, "auto-accessor fields ('accessor x')");
                 }
+                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?.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(fieldName);
+                    if (previous) {
+                        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 computed fields at a different type");
+                        }
+                        fieldOrder.push({ name: fieldName, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}), redeclared: true });
+                    }
+                    else {
+                        fields.set(fieldName, type);
+                        fieldOrder.push({ name: fieldName, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}) });
+                    }
+                    if (symbolKey)
+                        symbolFields.set(symbolKey.identity, fieldName);
+                    continue;
+                }
                 // #private fields ride the ordinary field machinery — the '#'
                 // name is unspellable publicly, so the slot never collides, and
                 // enumeration surfaces (inspect) exclude it like Node.
@@ -1232,14 +1634,27 @@ mixin) {
                 // undefined arm (undefFieldInitLineC — Node defines the property
                 // as undefined on construction, verified), and reads/writes ride
                 // the ordinary undefined-armed union machinery.
-                const type = lowerer.irTypeOf(member.name);
+                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") {
+                    type = lowerer.withUndefinedArmOf(type) ?? DYN;
+                }
                 if (type.kind === "void")
                     lowerer.badType(member.name, lowerer.typeOf(member.name));
-                // dyn stays out of class fields (KEEP NARROW; record
-                // fields and array elements are unmappable via mapType already).
-                if (type.kind === "dyn") {
+                // Bundled JS declares fields without annotations before assigning
+                // them in the constructor. Use the same native checked-dynamic
+                // storage as implicit constructor-assigned JS fields.
+                if (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile())) {
                     lowerer.unsupported("SC1090", member.name, "'unknown'-typed class fields");
                 }
+                const undefinedInitializer = type.kind === "dyn" && !member.initializer ? locOf(member) : undefined;
                 if (fields.has(member.name.text)) {
                     // REDECLARING an inherited field: Node [[Define]]s the OWN
                     // property again when THIS class's field initializers run
@@ -1249,13 +1664,12 @@ mixin) {
                     // slot, no new slot, no layout change (the `class
                     // ConfigError extends Error { name = "ConfigError" }`; the
                     // builtin Error prefix included — reads, toString, and throw
-                    // reports all answer the overwritten name like Node). A BARE
-                    // redeclare writes undefined in Node (`class B extends A
-                    // { x; }` reads undefined!) and a type-changing redeclare has
-                    // no single slot type — both keep the fence.
+                    // reports all answer the overwritten name like Node). A bare
+                    // JS dyn redeclaration resets the existing slot to undefined.
+                    // Other bare or type-changing redeclarations keep the fence.
                     const baseType = fields.get(member.name.text);
-                    if (member.initializer && typeEquals(type, baseType)) {
-                        fieldOrder.push({ name: member.name.text, type, initializer: member.initializer, redeclared: true });
+                    if ((member.initializer || type.kind === "dyn") && typeEquals(type, baseType)) {
+                        fieldOrder.push({ name: member.name.text, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}), redeclared: true });
                         continue;
                     }
                     lowerer.unsupported("SC1090", member.name, member.initializer
@@ -1280,7 +1694,7 @@ mixin) {
                 // (the constructor may be declared later in the class body).
                 const admitsUndefined = (type.kind === "union" &&
                     (lowerer.unions.get(type.unionId)?.arms.some((a) => a.kind === "undefinedT") ?? false)) ||
-                    type.kind === "jsval";
+                    type.kind === "jsval" || type.kind === "dyn";
                 if (!member.initializer && !admitsUndefined) {
                     const opts = lowerer.program.getCompilerOptions();
                     const spi = opts.strictPropertyInitialization ?? opts.strict ?? false;
@@ -1300,7 +1714,7 @@ mixin) {
                     }
                 }
                 fields.set(member.name.text, type);
-                fieldOrder.push({ name: member.name.text, type, initializer: member.initializer });
+                fieldOrder.push({ name: member.name.text, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}) });
             }
             else if (ts.isConstructorDeclaration(member)) {
                 // A body-less constructor is an OVERLOAD SIGNATURE: type-world,
@@ -1344,6 +1758,9 @@ mixin) {
                         lowerer.unsupported("SC1090", p, "this parameter property form");
                     }
                     const name = p.name.text;
+                    if (errorRooted && name === "cause") {
+                        lowerer.unsupported("SC1090", p.name, "redeclaring Error.cause (pass the cause in the Error constructor options)");
+                    }
                     const shape = lowerer.paramShape(p);
                     const type = shape.bodyType ?? shape.type;
                     if (type.kind === "void")
@@ -1368,15 +1785,18 @@ mixin) {
                 const mName = classMemberNameOf(lowerer, member.name);
                 if (mName === null)
                     lowerer.unsupported("SC1090", member, "computed method names");
-                // Sync PUBLIC generator methods stay fenced because virtualCall
-                // dispatch cannot hold spawn wrappers. Async generator methods
-                // use the existing static async-method dispatch discipline;
-                // overrides fence below. #private generators are always direct.
-                const asyncGenerator = member.asteriskToken !== undefined &&
-                    member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
-                if (member.asteriskToken !== undefined && !asyncGenerator && !ts.isPrivateIdentifier(member.name)) {
-                    lowerer.unsupported("SC1071", member, "generator methods (a #private generator method compiles — privates never dispatch dynamically; or declare a module-level function* and call it from the method)");
+                if (ts.isComputedPropertyName(member.name)) {
+                    const key = classSymbolKeyOf(lowerer, member.name.expression);
+                    if (key) {
+                        if ([...symbolMethods, ...symbolFields].some(([identity, name]) => name === mName && identity !== key.identity)) {
+                            lowerer.unsupported("SC1090", member.name, `distinct symbol keys sharing the printable name '${symbolFieldDisplayName(mName)}' in one class`);
+                        }
+                        symbolMethods.set(key.identity, mName);
+                    }
                 }
+                // Generator calls use their spawn wrapper. Public methods are
+                // direct calls only when no subclass overrides the method;
+                // override chains involving generators fence below.
                 // An ABSTRACT method is a signature with no body — type-world,
                 // except that it declares the vtable slot: calls through
                 // base-typed receivers are ordinary virtual dispatch, and tsc
@@ -1431,20 +1851,9 @@ mixin) {
                     collectGenericMember(member, false);
                     continue;
                 }
-                // Async METHODS in JS classes simply do not COLLECT — each call
-                // fences at its own site (the JS deferral stance, the
-                // async-static precedent above), so a class whose driven
-                // surface is synchronous still compiles (commander: parse()
-                // works, parseAsync() traps where called). TS async methods
-                // collect below like any method: the body is an async
-                // IrFunction (fiber spawn wrapper, `this` as param 0), calls
-                // dispatch STATICALLY — override chains fence (the vtable slot
-                // machinery has no fiber-spawn story), so every call site is a
-                // direct call the emitter routes through the spawn wrapper.
-                if (member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
-                    isJsSourceFile(decl.getSourceFile())) {
-                    continue;
-                }
+                // Async methods collect with the same direct-call spawn wrapper
+                // for JavaScript and TypeScript classes. Override chains remain
+                // fenced below because vtable slots cannot enter that wrapper.
                 // IMPLICIT-ANY monomorphization (npm-static JS): a method whose
                 // signature carries bindable untyped params collects like a
                 // GENERIC method — into genericMethods, no vtable slot, one
@@ -1454,13 +1863,14 @@ mixin) {
                 // dispatch worlds could meet: an inherited declaration of the
                 // name (the override stays on the vtable), a shadowed field, or
                 // a generic-class instantiation's member.
-                if (implicitMonoFile(decl.getSourceFile()) &&
+                if (implicitMonoFile(decl.getSourceFile()) && !functionLocalClass(decl) &&
                     ts.isIdentifier(member.name) &&
+                    !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) &&
                     !findGenericMethodOn(lowerer, base, member.name.text)) {
-                    const implicit = implicitAnyParamSymbolsOf(lowerer, member);
+                    const implicit = implicitAnyParamSymbolsOf(lowerer, member, true);
                     if (implicit) {
                         genericMethods.set(member.name.text, {
                             decl: member,
@@ -1474,6 +1884,31 @@ 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.
+                const virtualArity = lowerer.virtualJsMethodArity.get(member) ?? shapes.length;
+                if (virtualArity > shapes.length && !bodyReadsArguments(member) &&
+                    shapes.every((p) => p.type.kind === "dyn" && (p.mode === "required" || p.mode === "omittable"))) {
+                    while (shapes.length < virtualArity)
+                        shapes.push({ type: DYN, mode: "omittable" });
+                }
                 if (fields.has(mName)) {
                     lowerer.unsupported("SC1090", member.name, "methods shadowing inherited fields");
                 }
@@ -1499,17 +1934,78 @@ mixin) {
                 // against the STATIC receiver's shape, so `m(x?: number)` and
                 // `m(x: number | undefined)` interchange soundly in overrides.
                 const overridden = lowerer.findMethodOn(base, mName);
-                if (overridden?.declarer.builtinError) {
-                    // Error.prototype.toString is a runtime implementation with no
-                    // vtable slot — calls to it are direct, so an override could
-                    // never be reached through a base-typed receiver.
-                    lowerer.unsupported("SC1090", member.name, `overriding the builtin Error method '${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 &&
+                        (base.def.name === overridden.sig.ret.className || lowerer.isSubclassOf(base.def.name, overridden.sig.ret.className)) &&
+                        returnsOnlyThis(member))
+                        ft.ret = overridden.sig.ret;
+                    // An unannotated JS parameter can use the base's typed ABI.
+                    // Defaults stay local to each declaration, so only inherited
+                    // required/optional slots participate in this refinement.
+                    for (let i = 0; i < shapes.length; i++) {
+                        const parameter = member.parameters[i];
+                        const inherited = overridden.sig.params[i];
+                        if (parameter && inherited && !parameter.type && !parameter.initializer && !parameter.dotDotDotToken &&
+                            shapes[i].type.kind === "dyn" && inherited.type.kind !== "dyn" &&
+                            (inherited.mode === "required" || inherited.mode === "omittable")) {
+                            shapes[i] = { ...inherited };
+                        }
+                    }
+                }
+                // JS overrides may ignore trailing arguments. Retain the base's
+                // checked-value ABI slots as unused parameters, and let shorter
+                // calls fill them with undefined. Typed tails and rest/arguments
+                // readers keep the exact-signature fence.
+                if (overridden && isJsSourceFile(member.getSourceFile()) &&
+                    shapes.length < overridden.sig.params.length &&
+                    !bodyReadsArguments(member) &&
+                    shapes.every((p, i) => (p.mode === "required" || p.mode === "omittable") && typeEquals(p.type, overridden.sig.params[i].type)) &&
+                    overridden.sig.params.slice(shapes.length).every((p) => p.type.kind === "dyn" && (p.mode === "required" || p.mode === "omittable"))) {
+                    shapes.push(...overridden.sig.params.slice(shapes.length).map((p) => ({ type: p.type, mode: "omittable" })));
                 }
                 if (overridden &&
                     (overridden.sig.params.length !== shapes.length ||
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
                         !typeEquals(overridden.sig.ret, ft.ret))) {
-                    lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                    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;
+                    if (fencedJsOverride) {
+                        // A dormant JS method must not poison the whole class. Keep
+                        // the inherited call/dispatch ABI and refuse at method entry;
+                        // lowering this body with the base signature would change JS.
+                        const returnOnly = overridden.sig.params.length === shapes.length &&
+                            overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) &&
+                            !member.parameters.some((parameter, index) => {
+                                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)`));
+                        shapes.splice(0, shapes.length, ...overridden.sig.params);
+                        ft.ret = overridden.sig.ret;
+                    }
+                    else {
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                    }
                 }
                 const asyncMember = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
                 // Async methods dispatch STATICALLY (the body enters through its
@@ -1519,7 +2015,10 @@ mixin) {
                 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)`);
                 }
-                // A #private GENERATOR method carries its channels on the sig:
+                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)`);
+                }
+                // A GENERATOR method carries its channels on the sig:
                 // the body lowers as a generator IrFunction (`this` as param 0),
                 // and every call — direct by construction — enters through the
                 // emitted gen-spawn wrapper, answering the suspended generator.
@@ -1552,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
@@ -1562,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");
                 }
@@ -1609,7 +2117,7 @@ mixin) {
                 lowerer.unsupported("SC1090", member, "index signatures");
             }
             else if (!ts.isSemicolonClassElement(member)) {
-                lowerer.unsupported("SC1090", member, `syntax '${ts.SyntaxKind[member.kind]}'`);
+                lowerer.unsupported("SC1090", member, `syntax '${ts.syntaxKindName(member.kind)}'`);
             }
         }
         // Parameter properties join the shape FIRST among own fields —
@@ -1724,6 +2232,9 @@ mixin) {
         // forbids via strictPropertyInitialization — so they keep a named
         // fence instead of a silent undefined.
         if (isJsSourceFile(decl.getSourceFile())) {
+            const hasAccessor = (name) => methods.has(`get:${name}`) || methods.has(`set:${name}`) ||
+                lowerer.findMethodOn(base, `get:${name}`) !== null ||
+                lowerer.findMethodOn(base, `set:${name}`) !== null;
             // Named classes (declarations and self-binding expressions) resolve
             // by name; the nameless default-export declaration by its module's
             // default-export symbol.
@@ -1755,9 +2266,11 @@ mixin) {
                         lhs.expression.kind === ts.SyntaxKind.ThisKeyword) {
                         const assign = lhs;
                         const name = assign.name.text;
+                        if (errorRooted && name === "cause")
+                            continue;
                         // Later assignments to an already-declared field (own or
                         // inherited) are writes, not declarations.
-                        if (fields.has(name))
+                        if (fields.has(name) || hasAccessor(name))
                             continue;
                         if (methods.has(name) || lowerer.findMethodOn(base, name)) {
                             lowerer.unsupported("SC1090", assign, "constructor-assigned fields shadowing methods");
@@ -1772,11 +2285,16 @@ mixin) {
                         // TS-annotated `unknown` fields keep their fence (KEEP NARROW
                         // applies where an annotation could say better).
                         let type = t ? (lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, assign, t)) : null;
+                        if (t && (t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0 && isJsSourceFile(decl.getSourceFile()))
+                            type = DYN;
+                        if (type)
+                            type = jsOpenObjectType(assign, type, lowerer.shapes, lowerer.unions);
                         if (type?.kind === "dyn") {
                             type = inferredEmptyCollectionFieldType(lowerer, decl, name, rhs) ?? type;
                         }
                         if (!type || type.kind === "void")
                             lowerer.badType(assign, t ?? lowerer.typeOf(assign));
+                        type = jsFieldInitializerType(lowerer, type, rhs);
                         // A JSDoc claim the BODY contradicts (`@type {Command}`
                         // assigned `undefined` — the lazy-init idiom): the
                         // representation follows the body — the field widens to the
@@ -1801,7 +2319,7 @@ mixin) {
                         continue;
                     }
                     // `this[kLimit] = v` at the constructor's top level with a
-                    // STATICALLY-RESOLVABLE unique-symbol key (uniqueSymbolKeyOf's
+                    // STATICALLY-RESOLVABLE symbol key (classSymbolKeyOf's
                     // contract — the countdown.js idiom): the key is a compile-time
                     // identity, so the member is an ordinary hidden field of the
                     // static layout under Node's inspect spelling; no runtime
@@ -1811,19 +2329,30 @@ mixin) {
                     // late-bound fence below.
                     if (lhs && ts.isElementAccessExpression(lhs) &&
                         lhs.expression.kind === ts.SyntaxKind.ThisKeyword) {
-                        const key = uniqueSymbolKeyOf(lowerer, lhs.argumentExpression);
-                        if (!key)
+                        const key = classSymbolKeyOf(lowerer, lhs.argumentExpression);
+                        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.sym))
+                        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 '${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
@@ -1838,12 +2367,15 @@ mixin) {
                             : rhs
                                 ? lowerer.checker.getBaseTypeOfLiteralType(lowerer.checker.getTypeAtLocation(rhs))
                                 : undefined;
-                        const type = t ? (lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, lhs, t)) : null;
+                        let type = t ? (lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, lhs, t)) : null;
+                        if (type)
+                            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.sym, 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 });
                     }
                 }
             }
@@ -1853,9 +2385,11 @@ mixin) {
             // static layouts cannot represent. Named fence, at the first
             // assignment site.
             for (const p of instType ? lowerer.checker.getPropertiesOfType(instType) : []) {
+                if (errorRooted && p.name === "cause")
+                    continue;
                 if (fields.has(p.name) || methods.has(p.name))
                     continue;
-                if (methods.has(`get:${p.name}`) || methods.has(`set:${p.name}`))
+                if (hasAccessor(p.name))
                     continue;
                 if (base && (base.fields.has(p.name) || lowerer.findMethodOn(base, p.name)))
                     continue;
@@ -1866,14 +2400,15 @@ mixin) {
                 // Late-bound properties: the ones the scan above collected are
                 // real fields under their printable names — skip. The rest keep
                 // a fence that names the supported form: keys that are runtime
-                // identities (symbol parameters, Symbol.for consts, computed
+                // identities (symbol parameters, mutable bindings, computed
                 // descriptions) or assignments outside the constructor's top
                 // level.
                 if (p.name.startsWith("__@")) {
                     const keySym = lateBoundKeySymOf(lowerer, p);
-                    if (keySym && symbolFields.has(keySym))
+                    const key = keySym ? classSymbolKeyOfSymbol(lowerer, keySym) : null;
+                    if (key && symbolFields.has(key.identity))
                         continue;
-                    lowerer.unsupported("SC1090", site, "symbol-keyed class fields outside the supported form (a module-level `const k = Symbol('desc')` key, assigned unconditionally at the top of the constructor)");
+                    lowerer.unsupported("SC1090", site, "symbol-keyed class fields outside the supported form (a stable module-level literal Symbol()/Symbol.for() key, assigned unconditionally at the top of the constructor)");
                 }
                 // JS classes: a property first assigned in a method or a
                 // conditional constructor position holds `undefined` until the
@@ -1888,6 +2423,11 @@ mixin) {
                 if (isJsSourceFile(decl.getSourceFile())) {
                     const armed = undefArmedFieldType(lowerer, p);
                     if (armed !== null) {
+                        // Unknown JS properties use the instance bag: they do not
+                        // exist until assigned, and a subclass may declare the same
+                        // name as an ordinary layout field.
+                        if (armed.kind === "dyn")
+                            continue;
                         fields.set(p.name, armed);
                         fieldOrder.push({ name: p.name, type: armed, initializer: undefined });
                         continue;
@@ -1925,8 +2465,14 @@ mixin) {
         // synthesized constructor forwards the same params to super).
         const ctorParams = ctor && !mixinForwarding
             ? lowerer.paramShapes(ctor.parameters)
-            : (base?.ctorParams ?? []);
+            : (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
@@ -1935,6 +2481,9 @@ mixin) {
                 // INSTANTIATION prints its family's name — JS has one `Box`.
                 jsName: jsNameOverride ?? decl.name?.text ?? "",
                 ...(base ? { base: base.def.name } : {}),
+                jsLength: ctor?.parameters.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) === -1
+                    ? ctor.parameters.length
+                    : Math.max(0, ctor?.parameters.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) ?? 0),
                 // Layout order: the base chain's fields as an IDENTICAL prefix,
                 // then this class's own — what makes an upcast a reinterpret.
                 // Redeclared INHERITED fields contribute no slot (their
@@ -1955,18 +2504,22 @@ mixin) {
             fields,
             fieldOrder,
             methods,
+            ...(methodEntryFences.size > 0 ? { methodEntryFences } : {}),
             decl,
             ...(emitOverride !== undefined ? { emitOverride } : {}),
             ctor,
             ctorParams,
             ...(paramProps.length > 0 ? { paramProps } : {}),
             base,
+            ...(callableBase ? { callableBase } : {}),
+            ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
             throwingSetters,
             staticFields,
             ...(staticMethods.size > 0 ? { staticMethods } : {}),
             ...(staticBlocks.length > 0 ? { staticBlocks } : {}),
             ...(symbolFields.size > 0 ? { symbolFields } : {}),
+            ...(symbolMethods.size > 0 ? { symbolMethods } : {}),
             ...(classDecoratorNodes.length > 0 ? { classDecorators: { nodes: classDecoratorNodes } } : {}),
             ...(deferredInitFields.size > 0 ? { deferredInitFields } : {}),
         };
@@ -2020,6 +2573,17 @@ mixin) {
         if (base)
             base.subclasses.push(info);
         lowerer.classes.set(className, info);
+        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
         // expressions inside their own bodies — tsc resolves both to this
         // symbol); a nameless default-export declaration binds its module's
@@ -2051,7 +2615,7 @@ mixin) {
    * unmapped, the fenced-JS-class story. Null answers (unmappable type
    * arguments, the instance cap, an uncollected family) make the whole
    * reference unmappable — per-site diagnostics own the fence. */
-export function genericClassInstanceType(lowerer, decl, ref) {
+export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     const gci = lowerer.genericClassByDecl.get(decl);
     if (!gci) {
         // The family never collected (a deferred/poisoned declaration): the
@@ -2078,7 +2642,7 @@ export function genericClassInstanceType(lowerer, decl, ref) {
     const mapped = [];
     if (args.length === gci.typeParams.length) {
         for (const a of args) {
-            const m = lowerer.mapTypeOf(a);
+            const m = lowerer.mapTypeOf(a, mapArgument);
             if (!m || m.kind === "void") {
                 // An UNBOUND type parameter argument (`Box<T>` outside any
                 // instantiation) stays honestly unmapped — nothing concrete is
@@ -2207,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
@@ -2218,6 +2800,39 @@ 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: 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 })),
         ...(info.staticBlocks ?? []).map((b) => ({ pos: b.getStart(), kind: "block", b })),
@@ -2232,13 +2847,25 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         const f = item.f;
         lowerer.stats.statementsTotal++;
         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) {
@@ -2246,6 +2873,11 @@ function lowerStaticFieldInitsInner(lowerer, info) {
                 throw e;
             lowerer.stats.statementsFailed++;
             lowerer.bumpFileStat(locOf(f.initializer).file, "failed");
+            if (isJsSourceFile(f.initializer.getSourceFile()) && lowerer.diagSink === null) {
+                const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { kind: "statement" });
+                if (fence)
+                    out.push(fence);
+            }
         }
     }
     return out;
@@ -2520,6 +3152,14 @@ 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");
+    }
     if (info.generic) {
         // `typeof Box` — the uninstantiated FAMILY as a value: no thunk, no
         // single constructor ABI. INSTANTIATIONS have class objects
@@ -2529,10 +3169,10 @@ export function classValueRef(lowerer, info, blame) {
     if (info.builtinError || info.builtinEmitter || info.builtinStream !== undefined) {
         lowerer.unsupported("SC1090", blame, `builtin classes as values ('${display}' is runtime-provided — reference program-declared classes instead)`);
     }
-    if (lowerer.inheritsBuiltinErrorCtor(info) || lowerer.inheritsBuiltinEmitterCtor(info) ||
+    if (lowerer.inheritsBuiltinEmitterCtor(info) ||
         inheritsBuiltinStreamCtor(lowerer, info) ||
         (() => { for (let c = info.base; c; c = c.base)
-            if (c.builtinError || c.builtinEmitter || c.builtinStream !== undefined)
+            if (c.builtinEmitter || c.builtinStream !== undefined)
                 return true; return false; })()) {
         lowerer.unsupported("SC1090", blame, `classes extending builtin bases as values ('${display}' inherits a runtime-provided constructor)`);
     }
@@ -2554,6 +3194,26 @@ export function ctorAbiEquals(lowerer, sub, sup) {
     const b = sup.ctorParams;
     return a.length === b.length && a.every((p, i) => p.mode === b[i].mode && typeEquals(p.type, b[i].type));
 }
+/** Writable storage for an own static field named through its exact class.
+ * Inherited writes create a new subclass property in JS, so they must not
+ * update the declaring class's global. */
+export function staticFieldWriteTarget(lowerer, access) {
+    if (access.questionDotToken || (!ts.isIdentifier(access.expression) && access.expression.kind !== ts.SyntaxKind.ThisKeyword))
+        return null;
+    const info = lowerer.exactClassOfReceiver(access.expression);
+    if (!info)
+        return null;
+    const found = lowerer.findStaticOn(info, access.name.text);
+    if (!found?.field)
+        return null;
+    if (found.declarer !== info) {
+        lowerer.unsupported("SC1090", access, `assigning the inherited static '${access.name.text}' through a subclass name (JS creates an OWN property on the subclass — assign through '${found.declarer.def.jsName ?? found.declarer.def.name}' instead)`);
+    }
+    if (found.field.readonly) {
+        lowerer.unsupported("SC1090", access, `assigning the readonly static '${access.name.text}'`);
+    }
+    return { id: found.field.globalId, type: found.field.type };
+}
 /** `C.x` where C is a class declared in the program and x a static
    * member of its chain: field reads are the module global, static
    * methods become interned closures, and `.name` folds to the class's
@@ -2561,17 +3221,20 @@ export function ctorAbiEquals(lowerer, sub, sup) {
    * 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))
+    if (!ts.isIdentifier(expr.expression) && expr.expression.kind !== ts.SyntaxKind.ThisKeyword)
         return null;
-    const symbol = lowerer.resolveValueSymbol(expr.expression);
+    const symbol = ts.isIdentifier(expr.expression) ? lowerer.resolveValueSymbol(expr.expression) : null;
     const info = (symbol ? lowerer.classBySymbol.get(symbol) : undefined) ??
         // A require binding over `module.exports = class {…}` (the alias
         // lands on the expression's own symbol): resolve/collect on demand,
         // or `C.name` below would fall through to paths that answer for
         // stdlib globals instead of this class.
         propertyAssignedClassInfoOf(lowerer, symbol) ??
+        exactClassOfReceiver(lowerer, expr.expression) ??
         undefined;
     if (!info)
         return null;
@@ -2584,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
@@ -2611,6 +3277,12 @@ 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 };
     return null;
 }
 /** NamedEvaluation's answer for a class expression's `.name`: its own
@@ -2635,19 +3307,12 @@ function namedEvaluationName(expr) {
         return p.name.text;
     return "";
 }
-/** A class EXPRESSION's ClassInfo: collection on first encounter (the
-   * declaration path over the shared ClassLikeDeclaration machinery, with
-   * NamedEvaluation supplying the runtime .name), idempotent per node —
-   * tryLowerExpression's speculative visits and the heritage recursion reuse the
-   * first collection. The honest v1 boundary is TOP-LEVEL evaluation
-   * positions only: each evaluation of a class expression in JS mints a
-   * DISTINCT class (fresh identity, fresh statics), and one immortal
-   * class object is exact only for expressions that evaluate exactly
-   * once. Statics-bearing expressions additionally restrict to positions
-   * where "immediately before the enclosing statement" IS the evaluation
-   * point (lowerFileInit drains pendingClassExprInits there). */
+/** Collect a class expression once per enclosing specialization. Function-local
+ * evaluations allocate fresh constructor objects; top-level expressions use
+ * immortal templates. Static initialization remains limited to whole top-level
+ * initializers, where pendingClassExprInits preserves its evaluation point. */
 export function lowerClassExpressionInfo(lowerer, expr) {
-    const cached = lowerer.exprClassInfoByNode.get(expr);
+    const cached = lowerer.exprClassInfoByName.get(lowerer.classNamer(expr));
     if (cached)
         return cached;
     // Reentrancy guard: heritage resolution can DEMAND another class
@@ -2660,16 +3325,41 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     if (lowerer.collectingExprClasses.has(expr)) {
         lowerer.unsupported("SC1090", expr, "class expressions whose extends chain re-enters their own collection (a cyclic base through property assignments)");
     }
-    if (lowerer.instantiationContext) {
-        lowerer.unsupported("SC1090", expr, "class expressions inside generic functions (each instantiation would need its own class)");
-    }
-    for (let p = expr.parent; !ts.isSourceFile(p); p = p.parent) {
-        if (ts.isFunctionLike(p) || ts.isClassStaticBlockDeclaration(p)) {
-            lowerer.unsupported("SC1090", expr, "class expressions inside functions (each evaluation creates a DISTINCT class in JS — fresh identity, fresh statics; declare the class at top level)");
+    let local = false;
+    for (let p = expr.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
+        if (ts.isClassStaticBlockDeclaration(p)) {
+            lowerer.unsupported("SC1090", expr, "class expressions inside static blocks");
         }
+        if (ts.isFunctionLike(p))
+            local = true;
+    }
+    if (local && expr.members.some((member) => member.name && ts.isPrivateIdentifier(member.name))) {
+        lowerer.unsupported("SC1090", expr, "function-local classes with private brands");
+    }
+    if (local && (expr.typeParameters?.length ||
+        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 {
@@ -2678,7 +3368,17 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     const info = lowerer.classes.get(lowerer.classNamer(expr));
     if (!info)
         throw new PoisonError(); // collection poisoned and reported
-    lowerer.exprClassInfoByNode.set(expr, info);
+    if (local) {
+        info.def.localCaptures = [];
+        info.def.fields.push({ name: `%classEnvironment:${info.def.name}`, type: { kind: "classval", className: info.def.name } });
+        info.localClass = { context: null, bodies: new Map(), captureSources: [], ready: false };
+        if (info.base?.localClass) {
+            const baseExpression = expr.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+            if (baseExpression)
+                info.localClass.baseExpression = baseExpression;
+        }
+    }
+    lowerer.exprClassInfoByName.set(info.def.name, info);
     lowerer.exprClasses.push(info);
     lowerer.onExprClassCollected?.(info);
     // Static field initializers and static blocks run when the class
@@ -2688,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)) {
@@ -2708,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;
 }
@@ -2733,7 +3432,77 @@ export function lowerClassExpression(lowerer, expr) {
             }
         }
     }
-    return classValueRef(lowerer, lowerClassExpressionInfo(lowerer, expr), 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;
+        lowerer.fnStack.push(context);
+        try {
+            const bodies = lowerClassMembers(lowerer, info);
+            for (const body of bodies)
+                info.localClass.bodies.set(body.name, body);
+            info.def.localCaptures = context.captures;
+            info.localClass.captureSources = context.captureSources;
+            if (info.localClass.baseExpression && info.base) {
+                info.def.localBaseCapture = info.def.localCaptures.length;
+                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();
+            info.localClass.context = null;
+        }
+    }
+    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.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);
+        const baseRef = { kind: "varRef", localId: baseLocal.id, type: base.type, loc };
+        const clsRef = { kind: "varRef", localId: clsLocal.id, type: value.type, loc };
+        const basePrototype = classPrototypeData(lowerer, info.base, loc, baseRef);
+        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, 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 });
+    }
+    return initializeRuntimeStatics(lowerer, info, info.localClass && value.kind === "classRef"
+        ? { ...value, captures: info.localClass.captureSources }
+        : 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
@@ -2742,6 +3511,12 @@ 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) {
+    // 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) {
+        const receiver = lowerer.resolveThis();
+        return receiver?.type.kind === "classval" ? lowerer.classes.get(receiver.type.className) ?? null : null;
+    }
     if (!ts.isIdentifier(expr))
         return null;
     const symbol = lowerer.resolveValueSymbol(expr);
@@ -2764,7 +3539,7 @@ export function exactClassOfReceiver(lowerer, expr) {
     while (ts.isParenthesizedExpression(init))
         init = init.expression;
     if (ts.isClassExpression(init))
-        return lowerer.exprClassInfoByNode.get(init) ?? null;
+        return lowerer.exprClassInfoByName.get(lowerer.classNamer(init)) ?? null;
     if (ts.isIdentifier(init)) {
         const initSym = lowerer.resolveValueSymbol(init);
         const aliased = initSym ? (lowerer.classBySymbol.get(initSym) ?? null) : null;
@@ -2880,12 +3655,37 @@ function countAssignmentsTo(assign) {
 export function lowerStaticMethodCall(lowerer, call, access) {
     if (access.questionDotToken)
         return null;
+    if (access.expression.kind === ts.SyntaxKind.ThisKeyword) {
+        const receiver = lowerer.resolveThis();
+        const info = receiver?.type.kind === "classval" ? lowerer.classes.get(receiver.type.className) : undefined;
+        if (info)
+            return staticCallOn(lowerer, call, access, info, false);
+    }
     // `module.exports.describe()` in a module whose whole export IS a
     // class expression: the receiver is exactly that class (the kept
     // export assignment pins it) — the direct-name rules apply.
     if (!ts.isIdentifier(access.expression)) {
-        if (!isModuleExportsAccess(access.expression) || !isCjsJsFile(access.getSourceFile())) {
-            return null;
+        if (!isModuleExportsAccess(access.expression) || !isCjsJsFile(access.getSourceFile(), lowerer.program)) {
+            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);
+            if (!info)
+                return null;
+            const result = staticCallOn(lowerer, call, access, info, true);
+            if (!result)
+                return null;
+            // Evaluate and validate the receiver before evaluating arguments.
+            // A typed checker projection cannot turn a replaced field into a call
+            // to the class that originally occupied it.
+            const receiver = lowerer.lowerExprExpecting(access.expression, receiverType);
+            return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: receiver, loc: locOf(access.expression) }],
+                result, type: result.type, loc: locOf(call) };
         }
         const whole = cjsClassExprWholeExportOf(access.getSourceFile());
         if (!whole)
@@ -2928,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
@@ -2951,13 +3755,19 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         if (throughValue && staticShadowBelow(lowerer, info, access.name.text)) {
             lowerer.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
         }
-        const instance = genericCallInstance(lowerer, call, gfound.info);
+        const instance = genericCallInstance(lowerer, call, staticMethodForReceiver(lowerer, access, gfound.info, info, throughValue));
         const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
         return { kind: "call", callee: instance.name, args, type: instance.returnType, loc };
     }
     if (throughValue && staticShadowBelow(lowerer, info, access.name.text)) {
         lowerer.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
     }
+    const specialized = findGenericStaticOn(lowerer, info, access.name.text);
+    if (specialized?.declarer === found.declarer && specialized.info.implicitParams) {
+        const instance = implicitCallInstance(lowerer, call, staticMethodForReceiver(lowerer, access, specialized.info, info, throughValue));
+        const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
+        return { kind: "call", callee: instance.name, args, type: instance.returnType, loc };
+    }
     if (found.field !== undefined) {
         // A func-typed static field in call position: read the global,
         // call through the value (the ctor-assigned-callback pattern).
@@ -2973,13 +3783,44 @@ 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 ??= {
+            decl: found.method.member, baseName: access.name.text,
+            qualifiedName: `%${found.declarer.def.name}.static:${access.name.text}`,
+            typeParams: [], instances: new Map(), member: { cls: found.declarer, kind: "static" },
+        };
+        const instance = genericCallInstance(lowerer, call, staticMethodForReceiver(lowerer, access, generic, info, throughValue));
+        return { kind: "call", callee: instance.name,
+            args: lowerer.completeArgs(call.arguments, instance.params, loc, call), type: instance.returnType, loc };
     }
     const fnName = `%${found.declarer.def.name}.static:${access.name.text}`;
     lowerer.noteEdge(fnName);
     const args = lowerer.completeArgs(call.arguments, found.method.params, loc, call);
     return { kind: "call", callee: fnName, args, type: found.method.ret, loc };
 }
+function staticMethodForReceiver(lowerer, access, method, receiver, throughValue) {
+    if (!hasStaticThis(method.decl))
+        return method;
+    // A private name in the inherited body belongs to the declaring class,
+    // even when the receiver declares a different private with that spelling.
+    // Do not resolve it by receiver name until the static ABI tracks the brand.
+    if (method.member && method.member.cls !== receiver && hasLexicalPrivateReference(method.decl)) {
+        lowerer.unsupported("SC1090", access, "private member references in an inherited receiver-dependent static method");
+    }
+    if (throughValue && !classValueIsExactlyOwn(lowerer, access.expression, receiver)) {
+        lowerer.unsupported("SC1090", access, "receiver-dependent static methods through a polymorphic class value");
+    }
+    const instances = method.receiverSpecializations ??= new Map();
+    let specialized = instances.get(receiver.def.name);
+    if (!specialized) {
+        specialized = { ...method, qualifiedName: `${method.qualifiedName}%on.${receiver.def.name}`,
+            instances: new Map(), staticReceiver: receiver, receiverSpecializations: new Map() };
+        instances.set(receiver.def.name, specialized);
+    }
+    return specialized;
+}
 /** Static member access through a class VALUE (`X.m` where X is
    * classval-typed): devirtualized — the member resolves against the
    * static class's chain, exact when no strict descendant redeclares it
@@ -2990,11 +3831,15 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
 export function lowerClassValueProperty(lowerer, expr) {
     if (expr.questionDotToken)
         return null;
-    const recvT = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
+    const recvT = storedClassValueType(lowerer, expr.expression);
     if (recvT?.kind !== "classval")
         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.
@@ -3004,11 +3849,14 @@ 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
         // receiver is the exact exported class, and the read is
         // side-effect-free — as bindable as an identifier.
-        !(isModuleExportsAccess(expr.expression) && isCjsJsFile(expr.getSourceFile()))) {
+        !(isModuleExportsAccess(expr.expression) && isCjsJsFile(expr.getSourceFile(), lowerer.program))) {
         // Devirtualized reads DISCARD the receiver value, so only
         // side-effect-free receivers are claimed (the instanceOf fold
         // rule); computed ones meet the pointed fence with a bindable fix.
@@ -3016,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)`);
@@ -3110,9 +3955,75 @@ export function findGenericMethodOn(lowerer, info, name) {
    * method `name` — overrideBelow's twin: generic methods have no vtable
    * slot, so a call that could reach an override compiles only when the
    * receiver's runtime class is statically exact. */
-function genericOverrideBelow(lowerer, info, name) {
+export function genericOverrideBelow(lowerer, info, name) {
     return info.subclasses.some((s) => s.genericMethods?.has(name) === true || genericOverrideBelow(lowerer, s, name));
 }
+/** 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) {
+    // 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) &&
+                !member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
+            if (node.heritageClauses?.length && members.length > 0) {
+                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 === undefined || !target.isClassOrInterface() || seen.has(target))
+                        return;
+                    seen.add(target);
+                    for (const base of lowerer.checker.getBaseTypes(target)) {
+                        for (const member of members) {
+                            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.isMethodDeclaration(declaration) && isJsSourceFile(declaration.getSourceFile())) {
+                                    lowerer.virtualJsMethods.add(declaration);
+                                    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)) {
+                                        lowerer.virtualJsMethodArity.set(declaration, Math.max(lowerer.virtualJsMethodArity.get(declaration) ?? 0, member.parameters.length));
+                                    }
+                                }
+                            }
+                        }
+                        markBases(base);
+                    }
+                };
+                if (instance)
+                    markBases(instance);
+            }
+        }
+    };
+    for (const file of files)
+        ts.walkPreorder(file, visit);
+}
 /** The receiver's EXACT runtime class, when the expression proves it: a
    * `new C(...)` expression directly, or a const binding initialized with
    * one (the binding can never be reassigned to a subclass instance).
@@ -3274,13 +4185,20 @@ function mixinForwardingCtor(lowerer, ctor) {
     return !extraRef;
 }
 export function lowerClassMembers(lowerer, info) {
+    // Local class bodies are lowered when their expression captures its
+    // lexical environment. Type collection alone can discover a class in
+    // an owner skipped by the coverage remainder; it must not relower the
+    // constructor without that environment.
+    if (info.localClass && info.localClass.context === null) {
+        return [...info.localClass.bodies.values()];
+    }
     const out = [];
     const className = info.def.name;
     // Generic-class INSTANTIATIONS (and mixin instantiations) are
     // demand-driven like generic-fn instances, not reachability units:
     // they are never registered as units, so wantBody's name-keyed gate
     // cannot apply — every member of a demanded instantiation lowers.
-    const always = info.genericInstance !== undefined || info.mixinInstance !== undefined;
+    const always = info.genericInstance !== undefined || info.mixinInstance !== undefined || info.localClass !== undefined;
     // A FAMILY has no constructor function at all (nothing constructs it;
     // construction resolves to instantiations) and declares no instance
     // members — only its statics lower below.
@@ -3290,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)) {
@@ -3311,13 +4239,14 @@ export function lowerClassMembers(lowerer, info) {
                 throw e;
         }
     }
-    for (const name of info.staticMethods?.keys() ?? []) {
-        if (!lowerer.wantBody(`%${className}.static:${name}`))
-            continue;
-        const fn = lowerStaticMethod(lowerer, info, name);
-        if (fn)
-            out.push(fn);
-    }
+    if (info.staticMethods)
+        for (const [name] of info.staticMethods) {
+            if (!lowerer.wantBody(`%${className}.static:${name}`))
+                continue;
+            const fn = lowerStaticMethod(lowerer, info, name);
+            if (fn)
+                out.push(fn);
+        }
     for (const prop of info.throwingSetters) {
         if (always || lowerer.wantBody(`%${className}.set:${prop}`))
             out.push(lowerer.throwingSetterFn(info, prop));
@@ -3329,14 +4258,29 @@ export function lowerClassMembers(lowerer, info) {
    * the base's signature — forward every param to super(), then run own
    * field initializers. */
 export function lowerClassCtor(lowerer, info) {
+    const cached = info.localClass?.bodies.get(`%${info.def.name}.constructor`);
+    if (cached)
+        return cached;
     return withInstanceBindings(lowerer, info, () => lowerClassCtorInner(lowerer, info));
 }
+function classCaptureParams(info, context) {
+    if (!info.localClass)
+        return {};
+    const environment = info.localClass.context;
+    if (!environment)
+        throw new InternalCompilerError("local class lowered outside its lexical environment");
+    return { classCaptures: (context.captures ?? []).map((capture, index) => {
+            if (!capture)
+                throw new InternalCompilerError("missing local class capture");
+            return { ...capture, slot: environment.captures.findIndex((entry) => entry.localId === context.captureSources[index]) };
+        }) };
+}
 function lowerClassCtorInner(lowerer, info) {
     const className = info.def.name;
     const thisType = { kind: "object", className };
     const prevClass = lowerer.currentClass;
     lowerer.currentClass = info;
-    lowerer.fnStack.push(newFnCtx(false, null, null, VOID));
+    lowerer.fnStack.push(newFnCtx(info.localClass !== undefined, null, null, VOID));
     try {
         const thisLocal = lowerer.declareThis(thisType);
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
@@ -3365,8 +4309,13 @@ 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) {
+            if (!ctorBase && !info.callableBase) {
                 // Node's base-class order: field initializers run at the start
                 // of construction, the parameter-property assignments open the
                 // constructor body (probed — a field initializer reading a
@@ -3381,7 +4330,7 @@ function lowerClassCtorInner(lowerer, info) {
             }
         }
         else {
-            if (ctorBase) {
+            if (ctorBase || info.callableBase) {
                 // Synthetic forwarding params (the inherited ABI signature).
                 // Nothing references them by symbol — only the super call below,
                 // which forwards the already-completed values UNCHANGED (defaults
@@ -3411,6 +4360,7 @@ function lowerClassCtorInner(lowerer, info) {
             params,
             returnType: VOID,
             locals: lowerer.ctx.locals,
+            ...classCaptureParams(info, lowerer.ctx),
             body,
             loc: locOf(info.ctor ?? info.decl),
         };
@@ -3450,7 +4400,7 @@ export function classMemberNameOf(lowerer, name) {
             return `sym:${member}`;
         }
     }
-    return lowerer.foldedStringKeyOf(name.expression);
+    return classSymbolKeyOf(lowerer, name.expression)?.fieldName ?? lowerer.foldedStringKeyOf(name.expression);
 }
 export function classIteratorOf(lowerer, t) {
     if (t.kind !== "object")
@@ -3651,12 +4601,17 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
    * (accessors are methods with property syntax: "get:x"/"set:x" entries —
    * see collectClassShape). */
 export function lowerClassMethodMember(lowerer, info, fnLike) {
+    if (info.localClass?.ready) {
+        const member = classMemberNameOf(lowerer, fnLike.name);
+        const name = ts.isMethodDeclaration(fnLike) ? member : `${ts.isGetAccessor(fnLike) ? "get" : "set"}:${member}`;
+        return info.localClass.bodies.get(`%${info.def.name}.${name}`) ?? null;
+    }
     return withInstanceBindings(lowerer, info, () => lowerClassMethodMemberInner(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)
@@ -3665,6 +4620,21 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
     const sig = info.methods.get(mName);
     if (!sig || !fnLike.body)
         return null;
+    const entryFence = info.methodEntryFences?.get(mName);
+    if (entryFence) {
+        lowerer.runtimeFences.push(entryFence);
+        return lowerer.deferToRuntimeFence(lowerer.diags.length, fnLike.name, {
+            kind: "function",
+            name: `%${className}.${mName}`,
+            params: [
+                { localId: "this.0", name: "this", type: thisType },
+                ...sig.params.map((p, i) => ({ localId: `p.${i}`, name: `p${i}`, type: p.type })),
+            ],
+            returnType: sig.ret,
+            fallback: entryFence,
+            allowDiagSink: true,
+        });
+    }
     const prevClass = lowerer.currentClass;
     lowerer.currentClass = info;
     // ASYNC methods: the module function is an async IrFunction — its
@@ -3674,18 +4644,16 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
     // spawn's argument pack). Dispatch is static by construction — the
     // override fence at collection keeps async methods out of vtables.
     const isAsync = sig.async === true;
-    // #PRIVATE GENERATOR methods: the module function is a generator
-    // IrFunction — the body returns the TReturn channel, yields ride
-    // ctx.generator, and every call (direct by construction — privates
-    // never virtualize) enters through the emitted gen-spawn wrapper with
-    // `this` in the argument pack, answering the suspended generator.
+    // GENERATOR methods: the module function returns the TReturn channel,
+    // yields ride ctx.generator, and direct calls enter through the emitted
+    // gen-spawn wrapper with `this` in the argument pack.
     const genCh = sig.gen !== undefined && sig.ret.kind === "generator" ? sig.gen : null;
     const bodyReturn = genCh !== null
         ? lowerer.genBodyReturnType(sig.ret)
         : isAsync && sig.ret.kind === "promise"
             ? sig.ret.inner
             : sig.ret;
-    const fnCtx = newFnCtx(false, null, null, bodyReturn);
+    const fnCtx = newFnCtx(info.localClass !== undefined, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
     if (genCh !== null)
         fnCtx.generator = genCh;
@@ -3697,6 +4665,15 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
         // (JS allows this in method defaults; it is param 0 here).
         const declared = lowerer.declareParams(fnLike.parameters, sig.params);
         params.push(...declared.params);
+        // A shorter JS override still implements every inherited ABI slot.
+        // These tail parameters have no source binding or default prologue.
+        for (const shape of sig.params.slice(declared.params.length)) {
+            const name = shape.mode === "arguments" ? "%arguments" : "%ignored";
+            const local = lowerer.declareHiddenLocal(name, shape.type);
+            params.push({ localId: local.id, name, type: shape.type });
+            if (shape.mode === "arguments")
+                fnCtx.argumentsLocal = local;
+        }
         const body = [...declared.prologue, ...lowerer.lowerStmts(fnLike.body.statements)];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(fnLike));
         const fn = {
@@ -3704,6 +4681,7 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
             params,
             returnType: bodyReturn,
             locals: lowerer.ctx.locals,
+            ...classCaptureParams(info, lowerer.ctx),
             body,
             loc: locOf(fnLike),
         };
@@ -3729,18 +4707,31 @@ export function lowerStaticMethod(lowerer, info, name) {
     const entry = info.staticMethods?.get(name);
     if (!entry?.member.body)
         return null;
-    // Async statics: an async IrFunction like any module function — the
-    // body returns the promise's INNER type, calls enter through the
-    // fiber spawn wrapper (callTargetC routes by fn.async).
-    const isAsync = entry.member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true &&
-        entry.ret.kind === "promise";
-    const bodyReturn = isAsync && entry.ret.kind === "promise" ? entry.ret.inner : entry.ret;
+    const isAsync = entry.member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+    const isGenerator = entry.member.asteriskToken !== undefined;
+    if (isGenerator && (entry.ret.kind !== "generator" || (entry.ret.async === true) !== isAsync)) {
+        lowerer.badType(entry.member.name, lowerer.typeOf(entry.member.name));
+    }
+    if (isAsync && !isGenerator && entry.ret.kind !== "promise") {
+        lowerer.badType(entry.member.name, lowerer.typeOf(entry.member.name));
+    }
+    const genCh = isGenerator && entry.ret.kind === "generator" ? generatorMeta(lowerer, entry.ret) : null;
+    const bodyReturn = genCh !== null
+        ? lowerer.genBodyReturnType(entry.ret)
+        : isAsync && entry.ret.kind === "promise" ? entry.ret.inner : entry.ret;
     const fnCtx = newFnCtx(false, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
+    if (genCh !== null)
+        fnCtx.generator = genCh;
     lowerer.fnStack.push(fnCtx);
     try {
         rejectStaticThis(lowerer, entry.member.body, (keyword) => `'${keyword}' in static methods (it names the RECEIVER class — a dynamic value; reference the class by name instead)`);
         const declared = lowerer.declareParams(entry.member.parameters, entry.params);
+        if (entry.params.at(-1)?.mode === "arguments") {
+            const local = lowerer.declareHiddenLocal("%arguments", DYN);
+            declared.params.push({ localId: local.id, name: "%arguments", type: DYN });
+            fnCtx.argumentsLocal = local;
+        }
         const body = [...declared.prologue, ...lowerer.lowerStmts(entry.member.body.statements)];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(entry.member));
         const fn = {
@@ -3753,6 +4744,8 @@ export function lowerStaticMethod(lowerer, info, name) {
         };
         if (isAsync)
             fn.async = true;
+        if (genCh !== null)
+            fn.generator = genCh;
         return fn;
     }
     catch (e) {
@@ -3827,10 +4820,29 @@ 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({
+                kind: "fieldSet",
+                obj: { kind: "varRef", localId: thisLocal.id, type: thisType, loc },
+                className: info.def.name,
+                field: f.name,
+                value: dynUndefinedExpr(loc),
+                loc,
+            });
+        }
         if (!f.initializer)
             continue;
         lowerer.stats.statementsTotal++;
         lowerer.bumpFileStat(locOf(f.initializer).file, "total");
+        const diagsBefore = lowerer.diags.length;
         try {
             const value = lowerer.lowerExprExpecting(f.initializer, f.type);
             out.push({
@@ -3847,6 +4859,11 @@ export function fieldInitStmts(lowerer, info, thisLocal) {
                 throw e;
             lowerer.stats.statementsFailed++;
             lowerer.bumpFileStat(locOf(f.initializer).file, "failed");
+            if (isJsSourceFile(f.initializer.getSourceFile()) && lowerer.diagSink === null) {
+                const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, { kind: "statement" });
+                if (fence)
+                    out.push(fence);
+            }
         }
     }
     return out;
@@ -3882,80 +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;
-    for (const stmt of info.ctor.body.statements) {
-        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;
+    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));
         }
-        if (!lowerer.suppressStats) {
-            lowerer.stats.statementsTotal++;
-            lowerer.bumpFileStat(locOf(stmt).file, "total");
-        }
-        try {
-            if (superSeen)
-                lowerer.unsupported("SC1090", stmt, "multiple super() calls");
-            superSeen = true;
+        else {
             const base = superBaseOf(info);
-            if (base.builtinEmitter && superCall.arguments.length > 0) {
-                // @types/node admits super({ captureRejections }) — no lowering.
+            if (base.builtinEmitter && superCall.arguments.length > 0)
                 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;
+                statements.push(...lowerStreamSuperCall(lowerer, info, base, superCall.arguments, thisLocal, loc, superCall));
             }
-            const args = forward !== undefined
-                ? forward
-                : base.builtinError
-                    ? [lowerer.errorMessageArg(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");
+            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 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];
     }
-    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"));
+    finally {
+        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
@@ -3968,6 +4998,15 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         type: { kind: "object", className: info.def.name },
         loc,
     };
+    if (info.callableBase)
+        return {
+            kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classSuper",
+                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) {
         // super(message) into the runtime-provided Error constructor: stamps
         // name/message on the (already-allocated) object. Receiver + message
@@ -3977,7 +5016,7 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
             kind: "exprStmt",
             expr: {
                 kind: "libCall",
-                fn: "error.ctor",
+                fn: "error.ctorOptions",
                 args: [lowerer.upcastTo(thisRef, base.def.name), ...args],
                 type: VOID,
                 loc,
@@ -4081,9 +5120,22 @@ export function lowerSuperMethodCall(lowerer, call, access) {
     const thisLocal = lowerer.resolveThis();
     if (!thisLocal)
         lowerer.unsupported("SC1080", access);
-    lowerer.noteEdge(`%${found.declarer.def.name}.${access.name.text}`);
     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 };
+    }
+    lowerer.noteEdge(`%${found.declarer.def.name}.${access.name.text}`);
     const args = lowerer.completeArgs(call.arguments, found.sig.params, loc, call);
     return {
         kind: "call",
@@ -4163,8 +5215,8 @@ export function lowerSuperAccessorWrite(lowerer, access, rhs, loc) {
 }
 /** True when `info`'s EFFECTIVE constructor — its own, or the one
    * inherited through ctor-less bases — is a builtin error class's. Such
-   * classes construct with the error message rule, and their synthesized
-   * constructors forward one plain string to error.ctor. */
+   * classes construct with the error argument rule, and their synthesized
+   * constructors forward both checked-dynamic values to error.ctorOptions. */
 export function inheritsBuiltinErrorCtor(lowerer, info) {
     for (let c = info; c; c = c.base) {
         if (c.builtinError)
@@ -4201,25 +5253,18 @@ function inheritsBuiltinStreamCtor(lowerer, info) {
     }
     return false;
 }
-/** `new C(args)` for a class declared in the program (imports resolve
-   * through aliases, so cross-module classes construct too). */
-/** The single message argument of a builtin Error construction or
- * super() call: "" when omitted or explicitly undefined (Node's message
- * property default), the string otherwise. The lib signature's second
- * parameter (options/cause) has no lowering. */
-export function errorMessageArg(lowerer, args, loc, blame) {
-    if (args.length > 1) {
-        lowerer.unsupported("SC1090", args[1] ?? blame, "Error constructor options ('cause')");
-    }
-    if (args.length === 0)
-        return { kind: "strLit", value: "", type: STRING, loc };
-    const value = lowerer.lowerExpr(args[0]);
-    if (value.type.kind === "string")
-        return value;
-    if (value.kind === "unitLit" && value.unit === "undefined") {
-        return { kind: "strLit", value: "", type: STRING, loc };
-    }
-    lowerer.unsupported("SC1090", args[0], `Error messages of type '${lowerer.fmt(value.type)}' (the message must be a string)`);
+/** Preserve argument evaluation order and option presence through builtin
+ * and inherited Error constructors. Checked-dynamic conversion retains
+ * Error identity and distinguishes a missing cause from undefined. */
+export function errorConstructorArgs(lowerer, args, loc, blame) {
+    if (args.length > 2)
+        lowerer.unsupported("SC1090", blame, "Error constructors with more than two arguments");
+    return [0, 1].map((i) => {
+        const arg = args[i];
+        if (!arg)
+            return dynUndefinedExpr(loc);
+        return lowerer.lowerExprExpecting(arg, DYN);
+    });
 }
 /** `new C(...)` of a registered PROGRAM class — the shared tail of the
  * identifier and namespace-qualified construction forms. */
@@ -4252,6 +5297,8 @@ function fenceDecorationThrows(lowerer, info, blame) {
 function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
     const info = genericNewTarget(lowerer, expr, declaredInfo);
     fenceDecorationThrows(lowerer, info, expr);
+    if (info.localClass)
+        lowerer.unsupported("SC1090", expr, "construction through a function-local class's internal name");
     lowerer.noteEdge(`%${info.def.name}.constructor`);
     // A ctor-less chain into an EventEmitter base inherits `new C()` —
     // zero arguments (the options bag fences, like the super() form).
@@ -4263,12 +5310,16 @@ function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
     if (lowerer.inheritsBuiltinEmitterCtor(info) && (expr.arguments ?? []).length > 0) {
         lowerer.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
     }
-    // A ctor-less chain into a builtin error base inherits `new
-    // C(message?)` — completed by the error rule (one plain string),
-    // not the general ABI completion.
+    // A ctor-less chain into a builtin error base inherits both arguments;
+    // each synthesized constructor forwards the same pair to its base.
     const args = lowerer.inheritsBuiltinErrorCtor(info)
-        ? [lowerer.errorMessageArg(expr.arguments ?? [], loc, expr)]
+        ? 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,
@@ -4290,6 +5341,68 @@ function assignedThisFieldType(lowerer, expr) {
 }
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    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;
+    if (ts.isConditionalExpression(selected)) {
+        const yes = exactClassOfReceiver(lowerer, selected.whenTrue);
+        const no = exactClassOfReceiver(lowerer, selected.whenFalse);
+        if (yes && no && !yes.classDecorators && !no.classDecorators) {
+            const yesType = { kind: "object", className: yes.def.name };
+            const noType = { kind: "object", className: no.def.name };
+            const type = yes === no ? yesType : { kind: "union", unionId: lowerer.unions.intern([yesType, noType].sort((a, b) => typeKey(a) < typeKey(b) ? -1 : 1)) };
+            return { kind: "ternary", cond: lowerer.lowerCondition(selected.condition),
+                then: lowerer.coerceInto(expr, lowerProgramClassNew(lowerer, expr, yes, loc), type),
+                else_: lowerer.coerceInto(expr, lowerProgramClassNew(lowerer, expr, no, loc), type), type, loc };
+        }
+    }
+    if (ts.isPropertyAccessExpression(expr.expression) && expr.expression.name.text === "Segmenter" &&
+        lowerer.isStdlibGlobal(expr.expression.expression, "Intl")) {
+        const args = expr.arguments ?? [];
+        const undefinedArg = (arg) => (lowerer.typeOf(arg).flags & ts.TypeFlags.Undefined) !== 0;
+        if (args.length > 2 || (args[0] && !undefinedArg(args[0]))) {
+            lowerer.noLowering("Intl.Segmenter locale negotiation", expr, "omit the locale or pass undefined for default Unicode grapheme segmentation");
+        }
+        const options = args[1];
+        if (options && !undefinedArg(options) &&
+            !(ts.isObjectLiteralExpression(options) && options.properties.every((property) => ts.isPropertyAssignment(property) &&
+                (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) && property.name.text === "granularity" &&
+                ts.isStringLiteral(property.initializer) && property.initializer.text === "grapheme"))) {
+            lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options and { granularity: "grapheme" }; word and sentence segmentation remain unsupported');
+        }
+        // Explicit undefined expressions can carry effects; retain argument order.
+        const stmts = args.map((arg) => {
+            const value = lowerer.lowerExpr(arg);
+            return { kind: "exprStmt", expr: value.type.kind === "void" ? value : lowerer.coerceInto(arg, value, DYN), loc: locOf(arg) };
+        });
+        const result = { kind: "libCall", fn: "intl.segmenterNew", args: [], type: DYN, loc };
+        return stmts.length ? { kind: "seqExpr", stmts, result, type: DYN, loc } : result;
+    }
+    const consoleCtor = ts.isIdentifier(expr.expression)
+        ? lowerer.builtinImportOf(expr.expression)
+        : ts.isPropertyAccessExpression(expr.expression) &&
+            lowerer.builtinNamespaceModuleOf(expr.expression.expression) === "console"
+            ? { module: "console", member: expr.expression.name.text }
+            : null;
+    if (consoleCtor?.module === "console" && consoleCtor.member === "Console") {
+        lowerer.noLowering("new console.Console", expr, builtinFenceHintOf("console", "Console"));
+    }
     // `new X(...)` where X is a package-declared class, in a static build:
     // the per-package requires-dynamic diagnostic (the constructor runs in
     // the embedded engine). Under --dynamic, X is jsval-typed and lowers
@@ -4356,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
@@ -4381,7 +5496,7 @@ export function lowerNew(lowerer, expr) {
         // member-export symbol's; the class collects on demand (a body
         // lowering ahead of the assignment statement).
         if (!expr.expression.questionDotToken &&
-            ((isCjsJsFile(expr.getSourceFile()) &&
+            ((isCjsJsFile(expr.getSourceFile(), lowerer.program) &&
                 (isModuleExportsAccess(expr.expression.expression) ||
                     (ts.isIdentifier(expr.expression.expression) &&
                         expr.expression.expression.text === "exports" &&
@@ -4444,12 +5559,20 @@ 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);
-        // `new Error(msg?)` (and TypeError/RangeError/SyntaxError): the
+        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
         // runtime-provided classes construct through one libCall — the result
         // TYPE names which builtin, and the message completes to "" exactly
         // like Node's message property default.
@@ -4487,11 +5610,11 @@ export function lowerNew(lowerer, expr) {
             };
         }
         if (errInfo) {
-            const msg = lowerer.errorMessageArg(expr.arguments ?? [], loc, expr);
+            const args = lowerer.errorConstructorArgs(expr.arguments ?? [], loc, expr);
             return {
                 kind: "libCall",
-                fn: "error.new",
-                args: [msg],
+                fn: "error.newOptions",
+                args,
                 type: { kind: "object", className: errInfo.def.name },
                 loc,
             };
@@ -4519,25 +5642,40 @@ export function lowerNew(lowerer, expr) {
             return lowerStreamNew(lowerer, expr, streamInfo);
         // `new URL(input)`: the WHATWG URL class (stdlib/@types provenance —
         // a user's own `class URL` resolves through classBySymbol below).
-        // One string argument; invalid input throws a catchable TypeError
-        // ("Invalid URL"), like Node. The lib's base-argument form
-        // typechecks and is fenced here.
+        // Invalid input or base throws a catchable TypeError ("Invalid URL").
         // `new RegExp(pattern, flags?)`: runtime construction over the same
         // libregexp engine the literals ride. The pattern compiles EAGERLY,
         // so bad input throws Node's catchable SyntaxError at construction.
-        // String arguments only (Node also accepts a RegExp to copy — that
-        // form keeps the fence).
+        // Checked arguments retain native regexes and perform runtime coercion.
         if (symbol && symbol.name === "RegExp" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments ?? [];
             if (args.length > 2) {
                 lowerer.noLowering(`new RegExp with ${args.length} arguments`, expr);
             }
+            if (args.some(ts.isSpreadElement))
+                lowerer.noLowering("new RegExp with spread arguments", expr);
+            const values = args.map((arg) => lowerer.lowerExpr(arg));
+            if (values.some((value) => value.type.kind === "dyn" || value.type.kind === "regex")) {
+                const checked = [0, 1].map((index) => values[index]
+                    ? lowerer.coerceInto(args[index], values[index], DYN)
+                    : { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc });
+                return { kind: "libCall", fn: "regex.newChecked", args: checked, type: { kind: "regex" }, loc };
+            }
             const strArg = (a, what) => {
                 if (!a)
                     return { kind: "strLit", value: "", type: STRING, loc };
-                const v = lowerer.lowerExpr(a);
+                const v = values[args.indexOf(a)];
+                const empty = { kind: "strLit", value: "", type: STRING, loc };
+                if (v.type.kind === "undefinedT") {
+                    if (v.kind === "unitLit")
+                        return empty;
+                    return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: lowerer.coerceToExpected(v, DYN), loc: locOf(a) }], result: empty, type: STRING, loc };
+                }
+                if (v.type.kind === "union" && lowerer.unions.get(v.type.unionId)?.arms.every((arm) => arm.kind === "string" || arm.kind === "undefinedT")) {
+                    return { kind: "nullish", left: v, right: empty, type: STRING, loc: locOf(a) };
+                }
                 if (v.type.kind !== "string") {
-                    lowerer.noLowering(`new RegExp with a '${lowerer.fmt(v.type)}' ${what}`, a, "string arguments are the lowered form (a RegExp copy or ToString coercion has no lowering)");
+                    lowerer.noLowering(`new RegExp with a '${lowerer.fmt(v.type)}' ${what}`, a, "string or undefined arguments are the lowered form (a RegExp copy or ToString coercion has no lowering)");
                 }
                 return v;
             };
@@ -4546,25 +5684,7 @@ export function lowerNew(lowerer, expr) {
             return { kind: "libCall", fn: "regex.new", args: [pattern, flags], type: { kind: "regex" }, loc };
         }
         if (symbol && symbol.name === "URL" && lowerer.isStdlibSymbol(symbol)) {
-            const args = expr.arguments ?? [];
-            if (args.length === 2) {
-                const folded = staticForkString(lowerer.program, expr);
-                if (folded === null) {
-                    lowerer.noLowering("new URL with a runtime-valued base", expr, "a relative literal or statically resolvable template against import.meta.url compiles", symbol);
-                }
-                return {
-                    kind: "libCall",
-                    fn: "url.new",
-                    args: [{ kind: "strLit", value: folded, type: STRING, loc }],
-                    type: URL_T,
-                    loc,
-                };
-            }
-            if (args.length !== 1) {
-                lowerer.noLowering(`new URL with ${args.length} argument${args.length === 1 ? "" : "s"}`, expr, "one absolute-URL string, or a static relative input against import.meta.url, is supported", symbol);
-            }
-            const input = lowerer.lowerExprExpecting(args[0], STRING);
-            return { kind: "libCall", fn: "url.new", args: [input], type: URL_T, loc };
+            return lowerUrlNew(lowerer, expr);
         }
         // `new URLSearchParams(init?)`: the WHATWG list (stdlib provenance —
         // see lowerSearchParamsNew for the lowered init shapes).
@@ -4580,6 +5700,11 @@ export function lowerNew(lowerer, expr) {
             if (args.some(ts.isSpreadElement) || args.length > 1) {
                 lowerer.noLowering(`new Date with ${args.length} arguments`, expr, "new Date(), new Date(milliseconds), and new Date(dateString) are supported; the local-time year/month field constructor has no lowering", symbol);
             }
+            if (isJsSourceFile(expr.getSourceFile())) {
+                return { kind: "libCall", fn: "date.nativeNew", args: [
+                        { kind: "dynArrLit", elems: args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc },
+                    ], type: DYN, loc };
+            }
             if (args.length === 0) {
                 return { kind: "libCall", fn: "date.newNow", args: [], type: DATE_T, loc };
             }
@@ -4620,14 +5745,8 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
-        // Encoder objects likewise never exist: lowerTextCodecCall claims
-        // composed calls before the receiver lowers, while the same-scope
-        // const store-then-call declaration is erased before reaching here.
         if (symbol && (symbol.name === "TextDecoder" || symbol.name === "TextEncoder") && lowerer.isStdlibSymbol(symbol)) {
-            lowerer.noLowering(`new ${symbol.name}`, expr, `${symbol.name} values have no representation — a same-scope const store-then-call or the composed form compiles: ` +
-                (symbol.name === "TextDecoder"
-                    ? "new TextDecoder().decode(bytes)"
-                    : "new TextEncoder().encode(s)"), symbol);
+            return lowerTextCodecNew(lowerer, expr, symbol.name);
         }
         // `new Uint8Array(...)` / `new Uint32Array(...)` / `new
         // Float32Array(...)` / `new Float64Array(...)`: the typed-array
@@ -4646,7 +5765,7 @@ export function lowerNew(lowerer, expr) {
         // A rebindable decorated name constructs through its VALUE (the
         // classval-typed path below — newValue through the decoration
         // result's construct thunk), never the declaration directly.
-        if (info && info.classDecorators?.valueGlobalId === undefined) {
+        if (info && !info.localClass && info.classDecorators?.valueGlobalId === undefined) {
             return lowerProgramClassNew(lowerer, expr, info, loc);
         }
         // `new Map<K, V>()`: the lib Map constructor. The SEEDED forms: an
@@ -4654,27 +5773,17 @@ export function lowerNew(lowerer, expr) {
         // (`new Map([[k, v], ...])`) — each pair's key/value lower as
         // ordinary K/V-typed expressions and the backend set()s them in
         // order, so the tuple array never exists as a value — and a
-        // `[K, V][]`-typed tuple-array VALUE (lowerMapSeedArrayNew: a
+        // `[K, V][]`-typed tuple-array VALUE (lowerMapSeedNew: a
         // construct-and-set loop, pairs in array order, duplicates
-        // overwrite). Other seeds — another Map, general iterables — keep
-        // the fence: never silently an empty map. Unsupported key/value
+        // overwrite). Matching Maps copy their entries; nullish seeds make
+        // empty Maps. General iterable seeds retain a fence. Unsupported key/value
         // 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 ?? []);
@@ -4688,16 +5797,29 @@ export function lowerNew(lowerer, expr) {
                 : null;
             let tsType = lowerer.typeOf(expr);
             let mapped = lowerer.mapTypeOf(tsType);
+            if (mapped === null && isJsSourceFile(expr.getSourceFile()))
+                mapped = lowerer.irTypeOf(expr);
             const fieldType = assignedThisFieldType(lowerer, expr);
             if (mapped?.kind !== "map" && fieldType?.kind === "map")
                 mapped = fieldType;
+            // A fresh map built from pair literals can use its destination's
+            // layout directly. Inference may otherwise split record values
+            // into incompatible shapes (for example a nullable field), even
+            // though every seed fits the declared value type. Existing map or
+            // tuple-array values retain their own representation.
+            let parent = expr.parent;
+            while (ts.isParenthesizedExpression(parent))
+                parent = parent.parent;
+            // `satisfies` checks a view but retains the expression's own type.
+            const contextualSeed = !ts.isSatisfiesExpression(parent) && (expr.typeArguments?.length ?? 0) === 0 &&
+                (entriesLit !== null || (expr.arguments?.length ?? 0) === 0);
             // JavaScript's `new Map()` has no type-argument syntax: the no-arg
             // constructor overload pins Map<any, any> whatever the JSDoc says
             // (`@type` on the declaration types the VARIABLE, not this
             // expression). The CONTEXTUAL type carries the annotation — adopt
             // it when it is a supported map. TS type arguments keep winning:
             // their expression type already maps.
-            if (mapped?.kind !== "map") {
+            if (mapped?.kind !== "map" || contextualSeed) {
                 const ctx = lowerer.checker.getContextualType(expr);
                 const ctxMapped = ctx ? lowerer.mapTypeOf(ctx) : null;
                 if (ctx && ctxMapped?.kind === "map") {
@@ -4706,28 +5828,29 @@ export function lowerNew(lowerer, expr) {
                 }
             }
             if (seedArg && !entriesLit && mapped?.kind === "map") {
-                const seeded = lowerMapSeedArrayNew(lowerer, seedArg, mapped);
+                const seeded = lowerMapSeedNew(lowerer, seedArg, mapped);
                 if (seeded)
                     return seeded;
             }
             if ((expr.arguments?.length ?? 0) > 0 && !entriesLit) {
                 lowerer.noLowering("new Map(entries)", expr, "supported seeds: an array literal of [key, value] pair literals, or a " +
-                    "[K, V][]-typed tuple-array value — construct the Map empty and set() " +
-                    "each entry otherwise");
+                    "[K, V][]-typed tuple-array value, a matching Map, or null/undefined");
             }
             if (mapped?.kind === "map") {
                 if (!entriesLit)
                     return { kind: "mapNew", type: mapped, loc };
                 const seed = entriesLit.map((pair) => ({
-                    key: lowerer.lowerExprExpecting(pair.elements[0], mapped.key),
-                    value: lowerer.lowerExprExpecting(pair.elements[1], mapped.value),
+                    key: lowerer.lowerCollectionKey(pair.elements[0], mapped.key),
+                    value: mapped.value.kind === "dyn"
+                        ? lowerer.lowerCollectionKey(pair.elements[1], mapped.value)
+                        : lowerer.lowerExprExpecting(pair.elements[1], mapped.value),
                 }));
                 return { kind: "mapNew", seed, type: mapped, loc };
             }
             const targs = lowerer.checker.getTypeArguments(tsType);
             // JAVASCRIPT `new Map()` whose arguments never resolved past
             // Map<any, any> (no annotation, no contextual type, no seed): the
-            // WeakMap stance below — the VALUE lowers as an opaque dyn object
+            // The VALUE lowers as an opaque dyn object
             // (identity and truthiness are real), and every reached METHOD use
             // meets its own per-site fence at runtime. The formatter's
             // config-cache shape: module init constructs the caches
@@ -4740,34 +5863,35 @@ export function lowerNew(lowerer, expr) {
                 return { kind: "dynObjLit", type: DYN, loc };
             }
             const keyIr = targs[0] ? lowerer.mapTypeOf(targs[0]) : null;
-            if (targs[0] && (!keyIr || !isSupportedMapKey(keyIr))) {
+            if (targs[0] && (!keyIr || !isSupportedMapKey(keyIr, keyIr.kind === "union" ? lowerer.unions.get(keyIr.unionId)?.arms : undefined))) {
                 lowerer.unsupported("SC1090", expr, `Map keys of type '${lowerer.checker.typeToString(targs[0])}' ` +
-                    `(Map keys must be string or number)`);
+                    `(Map keys must be numbers, strings, identity references, or unions of identity references)`);
             }
             if (targs[1]) {
                 lowerer.unsupported("SC1090", expr, `Map values of type '${lowerer.checker.typeToString(targs[1])}' ` +
                     `(Map values must be number, string, boolean, records, class instances, ` +
-                    `arrays, promises, or unions of those — not functions, Maps, 'unknown', or 'any')`);
+                    `arrays, promises, Maps, Sets, or unions of those — not functions, 'unknown', or 'any')`);
             }
             lowerer.badType(expr, tsType);
         }
-        // `new Set<T>()`: Map's sibling. The SEEDED form lowers for arrays
-        // and fixed tuples of legal elements — literal or variable — as
-        // construct + bulk add (duplicates collapse, insertion order
-        // preserved, exactly JS). Other iterables keep the fence.
-        // Unsupported element types are named specifically.
-        // `new WeakMap()` / `new WeakSet()` in JAVASCRIPT sources: no weak
-        // container exists in the value model, but harness code constructs
-        // one unconditionally and touches it only on paths tests don't
-        // reach — the value lowers as an opaque dyn object (identity only;
-        // every reached METHOD use meets its own per-site fence → runtime
-        // fence). TypeScript keeps the compile fence.
-        if ((symbol?.name === "WeakMap" || symbol?.name === "WeakSet") &&
-            lowerer.isStdlibSymbol(symbol) &&
-            isJsSourceFile(expr.getSourceFile()) &&
-            (expr.arguments?.length ?? 0) === 0) {
-            return { kind: "dynObjLit", type: DYN, loc };
+        // Weak containers share checked native key identities and lifetime hooks.
+        if ((symbol?.name === "WeakMap" || symbol?.name === "WeakSet") && lowerer.isStdlibSymbol(symbol)) {
+            const args = expr.arguments ?? [];
+            if (args.length > 1 || args.some(ts.isSpreadElement)) {
+                lowerer.unsupported("SC1090", expr, `${symbol.name} construction with surplus or spread arguments`);
+            }
+            if (lowerer.dynamic) {
+                const ctor = { kind: "jsOp", op: "globalGet", name: symbol.name, args: [], type: JSVAL, loc };
+                return { kind: "jsOp", op: "construct", args: [ctor, ...args.map((arg) => lowerer.jsvalIn(lowerer.lowerExpr(arg), arg))], type: JSVAL, loc };
+            }
+            return {
+                kind: "libCall", fn: symbol.name === "WeakMap" ? "weakMap.new" : "weakSet.new",
+                args: [args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc)],
+                type: DYN, loc,
+            };
         }
+        // `new Set<T>()`: construct + bulk add from native arrays, tuples,
+        // or strings. Duplicates collapse in insertion order.
         if (symbol?.name === "Set" && lowerer.isStdlibSymbol(symbol)) {
             const tsType = lowerer.typeOf(expr);
             let mapped = lowerer.mapTypeOf(tsType);
@@ -4775,55 +5899,13 @@ export function lowerNew(lowerer, expr) {
             if (mapped?.kind !== "set" && fieldType?.kind === "set")
                 mapped = fieldType;
             if (mapped?.kind === "set" && (expr.arguments?.length ?? 0) === 1) {
-                const argNode = expr.arguments[0];
-                // An array LITERAL seed builds element-wise (its contextual type
-                // is the lib constructor's `readonly T[] | Iterable<T> | null`
-                // union — unmappable, so the generic literal path can't type it);
-                // an array-typed VALUE seed lowers as itself.
-                if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-                    const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, mapped.elem));
-                    const seed = { kind: "arrayLit", elems, type: arrayOf(mapped.elem), loc };
-                    return { kind: "setNew", seed, type: mapped, loc };
-                }
-                if (!ts.isSpreadElement(argNode)) {
-                    const argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
-                    if (argIr?.kind === "array" && typeEquals(argIr.elem, mapped.elem)) {
-                        let seed = lowerer.lowerExpr(argNode);
-                        // A T[]-DECLARED seed whose value is an island handle (a
-                        // package's exported array — the binding never held a
-                        // static array): the VALIDATED exit copies the engine
-                        // array out (strict elements, the catchable TypeError on a
-                        // lying handle), and the bulk add proceeds on the copy —
-                        // construction reads the seed once, so the aliasing
-                        // divergence has nothing to observe.
-                        if (seed.type.kind === "jsval" && lowerer.boundaryExitSafe(arrayOf(mapped.elem))) {
-                            seed = { kind: "jsExit", value: seed, type: arrayOf(mapped.elem), loc: seed.loc };
-                        }
-                        if (typeEquals(seed.type, arrayOf(mapped.elem))) {
-                            return { kind: "setNew", seed, type: mapped, loc };
-                        }
-                        // Any other lowered kind falls through to the named fence
-                        // below — never a mistyped seed into the validator.
-                    }
-                    // Fixed tuples use record storage, not T[] storage. Snapshot
-                    // their legal elements into an array before bulk insertion;
-                    // the helper takes the tuple as one argument, so an effectful
-                    // seed expression is evaluated exactly once.
-                    if (argIr?.kind === "record") {
-                        const shape = lowerer.shapes.get(argIr.shapeId);
-                        if (shape?.tuple && shape.fields.every((field) => typeEquals(field.type, mapped.elem))) {
-                            const seedType = { kind: "array", elem: mapped.elem };
-                            const helper = lowerer.tupleArrayWidthHelper(argIr.shapeId, seedType, loc);
-                            if (helper) {
-                                const tuple = lowerer.lowerExpr(argNode);
-                                if (typeEquals(tuple.type, argIr)) {
-                                    const seed = { kind: "call", callee: helper, args: [tuple], type: seedType, loc };
-                                    return { kind: "setNew", seed, type: mapped, loc };
-                                }
-                            }
-                        }
-                    }
-                }
+                const seeded = lowerSetSeedNew(lowerer, expr.arguments[0], mapped);
+                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
@@ -4847,15 +5929,15 @@ export function lowerNew(lowerer, expr) {
                 }
             }
             if ((expr.arguments?.length ?? 0) > 0) {
-                lowerer.noLowering("new Set(values)", expr, "construct the Set empty and add() each value — only an array or fixed tuple of " +
-                    "already-legal elements (string or number) seeds a Set");
+                lowerer.noLowering("new Set(values)", expr, "construct the Set empty and add() each value — only nullish values or a matching Set, string, array, or fixed tuple of " +
+                    "already-legal elements (numbers, strings, or identity references) seeds a Set");
             }
             if (mapped?.kind === "set")
                 return { kind: "setNew", type: mapped, loc };
             const targs = lowerer.checker.getTypeArguments(tsType);
             if (targs[0]) {
                 lowerer.unsupported("SC1090", expr, `Set elements of type '${lowerer.checker.typeToString(targs[0])}' ` +
-                    `(Set elements must be string or number — Map's key kinds — or a server handle, which stores under reference identity)`);
+                    `(Set elements must be numbers, strings, identity references, or unions of identity references)`);
             }
             lowerer.badType(expr, tsType);
         }
@@ -4961,16 +6043,14 @@ export function lowerNew(lowerer, expr) {
                 String: "boxed wrapper objects have no lowering — use the string primitive (the box is only distinguishable via typeof/identity, which nothing here can honor)",
                 Number: "boxed wrapper objects have no lowering — use the number primitive",
                 Boolean: "boxed wrapper objects have no lowering — use the boolean primitive",
-                WeakMap: "weak collections observe garbage collection, which reference counting never exposes — a strong Map behaves identically in-language: use Map",
-                WeakSet: "weak collections observe garbage collection, which reference counting never exposes — a strong Set behaves identically in-language: use Set",
                 WeakRef: "deref()-after-collect exposes GC timing — genuinely dynamic; hold a strong reference instead",
                 FinalizationRegistry: "finalization callbacks expose GC timing — genuinely dynamic; release resources explicitly instead",
                 SharedArrayBuffer: "no shared-memory threads exist in a compiled program — Uint8Array is the byte storage",
-                ArrayBuffer: "no free-standing ArrayBuffer value exists — typed arrays own their storage: allocate the view directly (new Uint8Array(n)), or erase a fresh buffer into one (new Uint8Array(new ArrayBuffer(n)), new DataView(new ArrayBuffer(n), ...))",
-                Proxy: "property-access metaprogramming has no static lowering (every property read must resolve at compile time)",
+                ArrayBuffer: "native ArrayBuffer construction supports fixed-length storage; resizable buffers remain unsupported",
+                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:
@@ -5055,7 +6135,7 @@ export function lowerNew(lowerer, expr) {
     // callee (unannotated heterogeneous registries) keeps a pointed
     // fence — annotate the slot with the common constructor type.
     {
-        const calleeT = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
+        const calleeT = storedClassValueType(lowerer, expr.expression);
         if (calleeT?.kind === "classval") {
             let info = lowerer.classes.get(calleeT.className);
             if (!info && ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.name)) {
@@ -5083,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`);
@@ -5132,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