@scriptc/compiler 0.2.4 → 0.2.6

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

@@ -1,3 +1,4 @@
+import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
  * (fields, methods, accessors, overrides), constructor/member lowering with
@@ -5,23 +6,32 @@ 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, 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, nodeThrowExpr, own } from "./lowerer.js";
-import { lowerArrayConstructor, lowerMapSeedNew, lowerObjectConstructor, lowerSetSeedNew } from "./lower-containers.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 { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, } from "./generic-functions.js";
+import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
+import { appendImplicitUndefinedReturn, hasExplicitJsDocReturn } from "./function-returns.js";
+import { bodyReadsArguments } from "../arguments-usage.js";
+import { generatorMeta } from "./call-signatures.js";
+import { omittedArgFor } from "./call-arguments.js";
+import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
+import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf, } from "../program.js";
+import { PoisonError, dynFallbackType, newFnCtx, own } from "./lowerer.js";
+import { lowerArrayConstructor } from "./containers/array-construction.js";
+import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
+import { lowerObjectConstructor } from "./containers/indexed-objects.js";
 import { bufEncoding } from "./containers/bytes.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.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 { lowerSearchParamsNew } from "./builtins/url.js";
+import { lowerTextCodecNew } from "./builtins/text-codecs.js";
+import { lowerWorkerNew } from "./builtins/workers.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 { classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName } from "./symbol-fields.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 { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
 import { hasLexicalPrivateReference, hasStaticThis, rejectStaticThis } from "./static-this.js";
 import { lowerUrlNew } from "./lower-url.js";
@@ -68,7 +78,9 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
     visiting.add(expression);
     if (ts.isParenthesizedExpression(expression))
         return storedClassValueType(lowerer, expression.expression, visiting);
-    if (ts.isClassExpression(expression) && !functionLocalClass(expression) && !lowerer.collectingExprClasses.has(expression)) {
+    if (ts.isClassExpression(expression) &&
+        !functionLocalClass(expression) &&
+        !lowerer.collectingExprClasses.has(expression)) {
         const info = lowerer.lowerClassExpressionInfo(expression);
         return { kind: "classval", className: info.def.name };
     }
@@ -87,7 +99,12 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
         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);
+        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")
@@ -100,7 +117,9 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
         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) &&
+            if (declaration &&
+                ts.isClassExpression(declaration) &&
+                !functionLocalClass(declaration) &&
                 !lowerer.collectingExprClasses.has(declaration)) {
                 const info = lowerer.lowerClassExpressionInfo(declaration);
                 return { kind: "classval", className: info.def.name };
@@ -134,7 +153,12 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
         }
         if (ts.isIdentifier(callee)) {
             const symbol = lowerer.resolveValueSymbol(callee);
-            const declaration = symbol && lowerer.checker.declarationsOf(symbol).find((decl) => ts.isVariableDeclaration(decl) && decl.initializer && (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0);
+            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;
@@ -142,13 +166,18 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
         }
         break;
     }
-    if ((ts.isArrowFunction(callee) || ts.isFunctionExpression(callee)) && isJsSourceFile(callee.getSourceFile()) &&
-        !callee.typeParameters?.length && !lowerer.preparingClassFactories.has(callee)) {
+    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;
+            result =
+                signatures.length === 1
+                    ? lowerer.checker.getReturnTypeOfSignature(signatures[0])
+                    : undefined;
         }
         if (result && lowerer.checker.getConstructSignatures(result).length > 0) {
             const returned = (value) => {
@@ -158,7 +187,9 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
                 return type.kind === "classval" ? type : null;
             };
             const home = callee.parent;
-            const generic = ts.isVariableDeclaration(home) && ts.isIdentifier(home.name) ? lowerer.genericFnOf(home.name) : null;
+            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);
@@ -202,10 +233,15 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
                 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) ||
+        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)) {
@@ -229,10 +265,10 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
     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
-   * or the ElementAccessExpression itself). Null when no declaration has
-   * that shape (well-known-symbol members like `[Symbol.iterator]`). */
+ * from the argument of the element-access assignment that declared it
+ * (`this[kLimit] = v` — the declaration list holds the BinaryExpression
+ * or the ElementAccessExpression itself). Null when no declaration has
+ * that shape (well-known-symbol members like `[Symbol.iterator]`). */
 function lateBoundKeySymOf(lowerer, p) {
     for (const d of lowerer.checker.declarationsOf(p)) {
         const access = ts.isBinaryExpression(d) && ts.isElementAccessExpression(d.left)
@@ -249,20 +285,20 @@ function lateBoundKeySymOf(lowerer, p) {
     return null;
 }
 /** Symbol-slot RETURN refinement (5.9.3 ABI parity): tsgo synthesizes no
-   * late-bound property for a JS class's `this[k] = v` declaration (the
-   * finding-5 family), so an unannotated method whose returns read a
-   * declared symbol-keyed slot infers `any` — the checked-dynamic
-   * fallback would box a value whose static type the class layout already
-   * knows (5.9.3 inferred it through the late-bound property; runtime
-   * output was identical either way, but the method ABI carried a dyn
-   * box). Recovered here from the layout itself, under a shape that
-   * cannot mis-type: an unannotated, non-async, non-generator JS method
-   * whose LAST top-level statement is a return (no fall-through
-   * `undefined` completion), where EVERY return statement (nested
-   * functions excluded — they return elsewhere) returns `this[k]` with a
-   * statically-resolved key declared in symbolFields, and all the slots
-   * agree on one IR type. Null when the shape doesn't hold — the value
-   * stays checked-dynamic exactly as before. */
+ * late-bound property for a JS class's `this[k] = v` declaration (the
+ * finding-5 family), so an unannotated method whose returns read a
+ * declared symbol-keyed slot infers `any` — the checked-dynamic
+ * fallback would box a value whose static type the class layout already
+ * knows (5.9.3 inferred it through the late-bound property; runtime
+ * output was identical either way, but the method ABI carried a dyn
+ * box). Recovered here from the layout itself, under a shape that
+ * cannot mis-type: an unannotated, non-async, non-generator JS method
+ * whose LAST top-level statement is a return (no fall-through
+ * `undefined` completion), where EVERY return statement (nested
+ * functions excluded — they return elsewhere) returns `this[k]` with a
+ * statically-resolved key declared in symbolFields, and all the slots
+ * agree on one IR type. Null when the shape doesn't hold — the value
+ * stays checked-dynamic exactly as before. */
 function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
     if (symbolFields.size === 0)
         return null;
@@ -308,12 +344,12 @@ function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
     return out;
 }
 /** 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()/
-   * toString reach them through dedicated error.* libCall lowerings, and
-   * user classes extend them like any base (the emitted subclass struct
-   * embeds ScrError's prefix). */
+ * 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()/
+ * toString reach them through dedicated error.* libCall lowerings, and
+ * user classes extend them like any base (the emitted subclass struct
+ * embeds ScrError's prefix). */
 export function registerBuiltinErrorClasses(lowerer) {
     const loc = { file: "<builtin>", start: 0, end: 0 };
     for (const [irName, rec] of RUNTIME_ERROR_CLASSES) {
@@ -363,7 +399,10 @@ export function registerBuiltinErrorClasses(lowerer) {
             ctor: null,
             // Inherited constructors forward both raw arguments. The runtime
             // applies the undefined message default and InstallErrorCause.
-            ctorParams: [{ type: DYN, mode: "omittable" }, { type: DYN, mode: "omittable" }],
+            ctorParams: [
+                { type: DYN, mode: "omittable" },
+                { type: DYN, mode: "omittable" },
+            ],
             base,
             subclasses: [],
             throwingSetters: [],
@@ -375,14 +414,14 @@ export function registerBuiltinErrorClasses(lowerer) {
     }
 }
 /** The runtime-provided node:events EventEmitter as an eagerly-registered
-   * ClassInfo (the error-hierarchy story): mapType names `%EventEmitter`
-   * the moment an emitter type appears, so the info must exist before any
-   * lowering. No decl, no lowerable bodies — `new`/super() reach it
-   * through emitter.* libCalls, the method surface lowers through
-   * lower-event-emitter.ts, and user classes extend it like any base (the
-   * emitted subclass struct embeds ScrEmitter's registry/name prefix —
-   * carried by the BACKEND, not by IR fields, so the fields list stays
-   * empty and subclass field layout starts right after the prefix). */
+ * ClassInfo (the error-hierarchy story): mapType names `%EventEmitter`
+ * the moment an emitter type appears, so the info must exist before any
+ * lowering. No decl, no lowerable bodies — `new`/super() reach it
+ * through emitter.* libCalls, the method surface lowers through
+ * lower-event-emitter.ts, and user classes extend it like any base (the
+ * emitted subclass struct embeds ScrEmitter's registry/name prefix —
+ * carried by the BACKEND, not by IR fields, so the fields list stays
+ * empty and subclass field layout starts right after the prefix). */
 export function registerBuiltinEmitterClass(lowerer) {
     const loc = { file: "<builtin>", start: 0, end: 0 };
     const info = {
@@ -404,13 +443,13 @@ export function registerBuiltinEmitterClass(lowerer) {
     lowerer.classes.set(RUNTIME_EMITTER_CLASS, info);
 }
 /** The runtime-provided node:stream classes as eagerly-registered
-   * ClassInfos (the emitter story): mapType names `%Readable` et al the
-   * moment a stream type appears, so the infos must exist before any
-   * lowering. Each roots at the emitter through its base chain, so the
-   * EventEmitter method surface, upcasts, and instanceof intervals apply
-   * unchanged; the stream method/property surface lowers through
-   * lower-stream.ts. No decl, no lowerable bodies, empty field lists —
-   * every instance is runtime-allocated (user `extends` is fenced). */
+ * ClassInfos (the emitter story): mapType names `%Readable` et al the
+ * moment a stream type appears, so the infos must exist before any
+ * lowering. Each roots at the emitter through its base chain, so the
+ * EventEmitter method surface, upcasts, and instanceof intervals apply
+ * unchanged; the stream method/property surface lowers through
+ * lower-stream.ts. No decl, no lowerable bodies, empty field lists —
+ * every instance is runtime-allocated (user `extends` is fenced). */
 export function registerBuiltinStreamClasses(lowerer) {
     const loc = { file: "<builtin>", start: 0, end: 0 };
     for (const [irName, rec] of RUNTIME_STREAM_CLASSES) {
@@ -437,12 +476,12 @@ export function registerBuiltinStreamClasses(lowerer) {
     }
 }
 /** The stream ClassInfo a VALUE symbol refers to (`new Readable(...)`,
-   * `x instanceof Writable`) — any import spelling resolves to the
-   * ambient class. Provenance: a stdlib-file CLASS declaration inside the
-   * "stream" ambient module, EXCLUDING @types/node's (whose stream.Readable
-   * also types child stdio — under @types/node the childStream mapping
-   * keeps priority and the static stream classes stand down; the shipped
-   * fallback declarations are the supported surface). */
+ * `x instanceof Writable`) — any import spelling resolves to the
+ * ambient class. Provenance: a stdlib-file CLASS declaration inside the
+ * "stream" ambient module, EXCLUDING @types/node's (whose stream.Readable
+ * also types child stdio — under @types/node the childStream mapping
+ * keeps priority and the static stream classes stand down; the shipped
+ * fallback declarations are the supported surface). */
 export function builtinStreamInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
@@ -454,7 +493,8 @@ export function builtinStreamInfoOf(lowerer, symbol) {
         // alias plumbing (streamClassAliasDecl — both declaration walks
         // skip it).
         const decl = lowerer.checker.valueDeclarationOf(symbol);
-        if (decl && ts.isVariableDeclaration(decl) &&
+        if (decl &&
+            ts.isVariableDeclaration(decl) &&
             (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
@@ -495,8 +535,12 @@ export function builtinStreamInfoOf(lowerer, symbol) {
 function jsFieldInitializerType(lowerer, type, expression) {
     if (ts.isIdentifier(expression)) {
         const symbol = lowerer.checker.getSymbolAtLocation(expression);
-        if (symbol && lowerer.checker.declarationsOf(symbol).some((decl) => ts.isParameter(decl) && (ts.isConstructorDeclaration(decl.parent) ||
-            (lowerer.typeOf(expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)))
+        if (symbol &&
+            lowerer.checker
+                .declarationsOf(symbol)
+                .some((decl) => ts.isParameter(decl) &&
+                (ts.isConstructorDeclaration(decl.parent) ||
+                    (lowerer.typeOf(expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)))
             return DYN;
     }
     if (type.kind === "array" || type.kind === "record")
@@ -507,17 +551,25 @@ function jsFieldInitializerType(lowerer, type, expression) {
     if (type.kind === "f64" && isJsSourceFile(expression.getSourceFile())) {
         const assignment = expression.parent;
         const left = ts.isBinaryExpression(assignment) ? assignment.left : null;
-        const field = left && ts.isPropertyAccessExpression(left) && left.expression.kind === ts.SyntaxKind.ThisKeyword ? left.name.text : null;
+        const field = left &&
+            ts.isPropertyAccessExpression(left) &&
+            left.expression.kind === ts.SyntaxKind.ThisKeyword
+            ? left.name.text
+            : null;
         let owner = expression.parent;
         while (owner && !ts.isClassDeclaration(owner) && !ts.isClassExpression(owner))
             owner = owner.parent;
         if (field && owner) {
             let acceptsUnchecked = false;
             const scan = (node) => {
-                if (acceptsUnchecked || node !== owner && (ts.isClassDeclaration(node) || ts.isClassExpression(node)))
+                if (acceptsUnchecked ||
+                    (node !== owner && (ts.isClassDeclaration(node) || ts.isClassExpression(node))))
                     return;
-                if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-                    ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword && node.left.name.text === field) {
+                if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isPropertyAccessExpression(node.left) &&
+                    node.left.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                    node.left.name.text === field) {
                     let rhs = node.right;
                     while (ts.isParenthesizedExpression(rhs))
                         rhs = rhs.expression;
@@ -538,14 +590,17 @@ function jsFieldInitializerType(lowerer, type, expression) {
         let prototypeArgument = false;
         for (const argument of node.arguments)
             ts.walkPreorder(argument, (part) => {
-                if (!ts.isPropertyAccessExpression(part) || part.expression.kind !== ts.SyntaxKind.ThisKeyword)
+                if (!ts.isPropertyAccessExpression(part) ||
+                    part.expression.kind !== ts.SyntaxKind.ThisKeyword)
                     return;
                 const symbol = lowerer.checker.getSymbolAtLocation(part.name);
-                if (symbol && lowerer.checker.declarationsOf(symbol).some((decl) => {
-                    const member = ts.isBinaryExpression(decl) ? decl.left : decl;
-                    return ts.isPropertyAccessExpression(member) && ts.isPropertyAccessExpression(member.expression) &&
-                        member.expression.name.text === "prototype";
-                }))
+                if (symbol &&
+                    lowerer.checker.declarationsOf(symbol).some((decl) => {
+                        const member = ts.isBinaryExpression(decl) ? decl.left : decl;
+                        return (ts.isPropertyAccessExpression(member) &&
+                            ts.isPropertyAccessExpression(member.expression) &&
+                            member.expression.name.text === "prototype");
+                    }))
                     prototypeArgument = true;
                 // JS checkers can synthesize a property declaration for prototype
                 // assignments. Keep the source ownership proof when that happens.
@@ -555,12 +610,17 @@ function jsFieldInitializerType(lowerer, type, expression) {
                 if (owner && (ts.isClassDeclaration(owner) || ts.isClassExpression(owner)) && owner.name) {
                     const className = owner.name.text;
                     for (const statement of owner.getSourceFile().statements) {
-                        if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression))
+                        if (!ts.isExpressionStatement(statement) ||
+                            !ts.isBinaryExpression(statement.expression))
                             continue;
                         const left = statement.expression.left;
-                        if (statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(left) &&
-                            left.name.text === part.name.text && ts.isPropertyAccessExpression(left.expression) && left.expression.name.text === "prototype" &&
-                            ts.isIdentifier(left.expression.expression) && left.expression.expression.text === className)
+                        if (statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                            ts.isPropertyAccessExpression(left) &&
+                            left.name.text === part.name.text &&
+                            ts.isPropertyAccessExpression(left.expression) &&
+                            left.expression.name.text === "prototype" &&
+                            ts.isIdentifier(left.expression.expression) &&
+                            left.expression.expression.text === className)
                             prototypeArgument = true;
                     }
                 }
@@ -572,7 +632,7 @@ function jsFieldInitializerType(lowerer, type, 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];
+        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)))
@@ -581,13 +641,22 @@ function jsFieldInitializerType(lowerer, type, expression) {
     if (node.kind === ts.SyntaxKind.NullKeyword)
         return withUnitArm(type, "nullT", lowerer.unions) ?? type;
     const inferred = lowerer.typeOf(node);
-    const scalar = (inferred.flags & ts.TypeFlags.BooleanLike) !== 0 ? "bool"
-        : (inferred.flags & ts.TypeFlags.NumberLike) !== 0 ? "f64"
-            : (inferred.flags & ts.TypeFlags.StringLike) !== 0 ? "string"
-                : (inferred.flags & ts.TypeFlags.BigIntLike) !== 0 ? "bigint"
-                    : (inferred.flags & ts.TypeFlags.ESSymbolLike) !== 0 ? "symbol" : null;
-    if (scalar && type.kind !== "dyn" && type.kind !== scalar &&
-        !(type.kind === "union" && lowerer.unions.get(type.unionId)?.arms.some((arm) => arm.kind === scalar)))
+    const scalar = (inferred.flags & ts.TypeFlags.BooleanLike) !== 0
+        ? "bool"
+        : (inferred.flags & ts.TypeFlags.NumberLike) !== 0
+            ? "f64"
+            : (inferred.flags & ts.TypeFlags.StringLike) !== 0
+                ? "string"
+                : (inferred.flags & ts.TypeFlags.BigIntLike) !== 0
+                    ? "bigint"
+                    : (inferred.flags & ts.TypeFlags.ESSymbolLike) !== 0
+                        ? "symbol"
+                        : null;
+    if (scalar &&
+        type.kind !== "dyn" &&
+        type.kind !== scalar &&
+        !(type.kind === "union" &&
+            lowerer.unions.get(type.unionId)?.arms.some((arm) => arm.kind === scalar)))
         return DYN;
     for (const arm of inferred.isUnionType() ? ts.constituentTypes(inferred) : [inferred]) {
         if ((arm.flags & ts.TypeFlags.Undefined) !== 0)
@@ -618,7 +687,10 @@ function inheritedJsFieldType(lowerer, decl, name, type) {
     return type;
 }
 function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
-    if (!isJsSourceFile(member.getSourceFile()) || member.type || member.asteriskToken || hasExplicitJsDocReturn(member))
+    if (!isJsSourceFile(member.getSourceFile()) ||
+        member.type ||
+        member.asteriskToken ||
+        hasExplicitJsDocReturn(member))
         return false;
     const widened = (expression) => {
         if (ts.isParenthesizedExpression(expression))
@@ -627,22 +699,38 @@ function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
             return widened(expression.whenTrue) || widened(expression.whenFalse);
         if (ts.isCallExpression(expression)) {
             const callee = expression.expression;
-            const symbol = ts.isPropertyAccessExpression(callee) ? lowerer.checker.getSymbolAtLocation(callee.name)
-                : ts.isElementAccessExpression(callee) ? lowerer.checker.getPropertyOfType(lowerer.typeOf(callee.expression), lowerer.foldedStringKeyOf(callee.argumentExpression) ?? "")
+            const symbol = ts.isPropertyAccessExpression(callee)
+                ? lowerer.checker.getSymbolAtLocation(callee.name)
+                : ts.isElementAccessExpression(callee)
+                    ? lowerer.checker.getPropertyOfType(lowerer.typeOf(callee.expression), lowerer.foldedStringKeyOf(callee.argumentExpression) ?? "")
                     : undefined;
-            if (symbol && lowerer.checker.declarationsOf(symbol).some((declaration) => ts.isMethodDeclaration(declaration) && lowerer.checkedVirtualJsMethods.has(declaration)))
+            if (symbol &&
+                lowerer.checker
+                    .declarationsOf(symbol)
+                    .some((declaration) => ts.isMethodDeclaration(declaration) &&
+                    lowerer.checkedVirtualJsMethods.has(declaration)))
                 return true;
         }
-        const name = ts.isPropertyAccessExpression(expression) ? expression.name.text
-            : ts.isElementAccessExpression(expression) ? lowerer.foldedStringKeyOf(expression.argumentExpression) : null;
+        const name = ts.isPropertyAccessExpression(expression)
+            ? expression.name.text
+            : ts.isElementAccessExpression(expression)
+                ? lowerer.foldedStringKeyOf(expression.argumentExpression)
+                : null;
         if (ts.isPropertyAccessExpression(expression)) {
             const symbol = lowerer.checker.getSymbolAtLocation(expression.name);
-            if (symbol && lowerer.checker.declarationsOf(symbol).some((declaration) => (ts.isGetAccessorDeclaration(declaration) || ts.isSetAccessorDeclaration(declaration)) && lowerer.checkedVirtualJsAccessors.has(declaration)))
+            if (symbol &&
+                lowerer.checker
+                    .declarationsOf(symbol)
+                    .some((declaration) => (ts.isGetAccessorDeclaration(declaration) ||
+                    ts.isSetAccessorDeclaration(declaration)) &&
+                    lowerer.checkedVirtualJsAccessors.has(declaration)))
                 return true;
         }
-        if (name !== null && (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) &&
+        if (name !== null &&
+            (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) &&
             expression.expression.kind === ts.SyntaxKind.ThisKeyword) {
-            return fields.get(name)?.kind === "dyn" || inheritedJsFieldType(lowerer, decl, name, ret).kind === "dyn";
+            return (fields.get(name)?.kind === "dyn" ||
+                inheritedJsFieldType(lowerer, decl, name, ret).kind === "dyn");
         }
         return false;
     };
@@ -659,10 +747,10 @@ function returnsWidenedJsField(lowerer, decl, member, fields, ret) {
     return result;
 }
 /** The undefined-armed union of a JS class property's inferred type — the
-   * honest slot for a field first assigned outside the constructor's top
-   * level (undefined until the write runs, Node-exact). Null when the
-   * inference is unmappable or an arm-less kind that cannot join a union
-   * (genResultRecord's list, including scalar-backed Date values). */
+ * 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 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 site = lowerer.checker.declarationsOf(p)[0];
@@ -673,7 +761,9 @@ function undefArmedFieldType(lowerer, p) {
         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) {
+        if (assignment &&
+            ts.isBinaryExpression(assignment) &&
+            assignment.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
             mapped = jsFieldInitializerType(lowerer, mapped, assignment.right);
         }
     }
@@ -683,8 +773,11 @@ function undefArmedFieldType(lowerer, p) {
     const byKey = new Map();
     const arms = mapped.kind === "union" ? (lowerer.unions.get(mapped.unionId)?.arms ?? []) : [mapped];
     for (const a of arms) {
-        if (a.kind === "map" || a.kind === "regex" || a.kind === "date" ||
-            a.kind === "jsval" || a.kind === "generator") {
+        if (a.kind === "map" ||
+            a.kind === "regex" ||
+            a.kind === "date" ||
+            a.kind === "jsval" ||
+            a.kind === "generator") {
             return null;
         }
         byKey.set(typeKey(a), a);
@@ -694,10 +787,10 @@ function undefArmedFieldType(lowerer, p) {
     return { kind: "union", unionId: lowerer.unions.intern(sorted) };
 }
 /** The emitter ClassInfo a VALUE symbol refers to (`new EventEmitter`,
-   * `extends EventEmitter`, `x instanceof EventEmitter`) — any import
-   * spelling (named/default/namespace member, CJS require) resolves to
-   * the ambient class. Provenance-checked like the error classes: only a
-   * stdlib-file declaration inside the "events" ambient module counts. */
+ * `extends EventEmitter`, `x instanceof EventEmitter`) — any import
+ * spelling (named/default/namespace member, CJS require) resolves to
+ * the ambient class. Provenance-checked like the error classes: only a
+ * stdlib-file declaration inside the "events" ambient module counts. */
 export function builtinEmitterInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
@@ -709,7 +802,8 @@ export function builtinEmitterInfoOf(lowerer, symbol) {
         // itself is alias plumbing (builtinMemberRequireDecl — both
         // declaration walks skip it).
         const decl = lowerer.checker.valueDeclarationOf(symbol);
-        if (decl !== undefined && ts.isVariableDeclaration(decl) &&
+        if (decl !== undefined &&
+            ts.isVariableDeclaration(decl) &&
             (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
@@ -737,9 +831,9 @@ export function builtinEmitterInfoOf(lowerer, symbol) {
     return declared ? (lowerer.classes.get(RUNTIME_EMITTER_CLASS) ?? null) : null;
 }
 /** The builtin error ClassInfo a VALUE symbol refers to (`new Error`,
-   * `extends TypeError`, `x instanceof RangeError`), or null. Provenance-
-   * checked: only the standard library's declarations count — a user's own
-   * `class Error` resolves through classBySymbol instead. */
+ * `extends TypeError`, `x instanceof RangeError`), or null. Provenance-
+ * checked: only the standard library's declarations count — a user's own
+ * `class Error` resolves through classBySymbol instead. */
 export function builtinErrorInfoOf(lowerer, symbol) {
     if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
@@ -753,22 +847,34 @@ export function builtinErrorInfoOf(lowerer, symbol) {
  * members with these names are fenced (collectClassShapeInner) and calls
  * to them on emitter-rooted receivers lower through lower-event-emitter.ts. */
 export const EMITTER_API_MEMBERS = new Set([
-    "on", "addListener", "once", "prependListener", "prependOnceListener",
-    "off", "removeListener", "removeAllListeners", "emit", "listenerCount",
-    "listeners", "rawListeners", "eventNames", "setMaxListeners", "getMaxListeners",
+    "on",
+    "addListener",
+    "once",
+    "prependListener",
+    "prependOnceListener",
+    "off",
+    "removeListener",
+    "removeAllListeners",
+    "emit",
+    "listenerCount",
+    "listeners",
+    "rawListeners",
+    "eventNames",
+    "setMaxListeners",
+    "getMaxListeners",
 ]);
 /** The decorators of a class-like or member node (they live in
-   * `modifiers` since TS 4.8). */
+ * `modifiers` since TS 4.8). */
 export function decoratorNodesOf(n) {
     return (n.modifiers ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
 }
 /** The AMBIENT name a decorator expression's evaluation throws on, or
-   * null. Node erases ambient declarations (`declare let dec: any`,
-   * `declare const instance: T`, `declare function dec<T>(t: T): T`), so
-   * reading the name is a ReferenceError. Factory spellings ride along —
-   * `@dec(...)` evaluates the CALLEE before any argument — and property
-   * chains throw at their ROOT (`@instance.decorate` reads `instance`
-   * first). */
+ * null. Node erases ambient declarations (`declare let dec: any`,
+ * `declare const instance: T`, `declare function dec<T>(t: T): T`), so
+ * reading the name is a ReferenceError. Factory spellings ride along —
+ * `@dec(...)` evaluates the CALLEE before any argument — and property
+ * chains throw at their ROOT (`@instance.decorate` reads `instance`
+ * first). */
 function ambientDecoratorThrowNameOf(lowerer, dExpr) {
     let e = dExpr;
     while (ts.isParenthesizedExpression(e))
@@ -785,16 +891,16 @@ function ambientDecoratorThrowNameOf(lowerer, dExpr) {
     return null;
 }
 /** The guaranteed decoration THROW of a decorated class, or null. Walks
-   * the class definition's evaluation-order items — class decorators
-   * (source order), the heritage expression, then per member in body
-   * order its decorators and computed key (the verified TC39/tsc-downlevel
-   * order) — and answers the first AMBIENT decorator name, provided every
-   * item BEFORE it is provably effect-free and non-throwing: bare
-   * identifier decorators over defined values (a pure read), an absent /
-   * `null` / bare-identifier heritage, literal or bare-identifier
-   * computed keys. Anything richer (factory calls over defined values,
-   * property-access reads, computed-key calls) stops the proof — the
-   * named fences answer instead. */
+ * the class definition's evaluation-order items — class decorators
+ * (source order), the heritage expression, then per member in body
+ * order its decorators and computed key (the verified TC39/tsc-downlevel
+ * order) — and answers the first AMBIENT decorator name, provided every
+ * item BEFORE it is provably effect-free and non-throwing: bare
+ * identifier decorators over defined values (a pure read), an absent /
+ * `null` / bare-identifier heritage, literal or bare-identifier
+ * computed keys. Anything richer (factory calls over defined values,
+ * property-access reads, computed-key calls) stops the proof — the
+ * named fences answer instead. */
 export function guaranteedDecorationThrow(lowerer, decl) {
     const stripParens = (e) => {
         let x = e;
@@ -819,8 +925,7 @@ export function guaranteedDecorationThrow(lowerer, decl) {
         if (v !== "effectFree")
             return v;
     }
-    const heritage = decl.heritageClauses
-        ?.find((c) => c.token === ts.SyntaxKind.ExtendsKeyword)
+    const heritage = decl.heritageClauses?.find((c) => c.token === ts.SyntaxKind.ExtendsKeyword)
         ?.types[0];
     if (heritage) {
         const h = stripParens(heritage.expression);
@@ -846,7 +951,36 @@ export function guaranteedDecorationThrow(lowerer, decl) {
     return null;
 }
 export function collectClassShape(lowerer, decl) {
-    const symbol = lowerer.collectDeferring(() => declSymbolOf(lowerer, decl), () => lowerer.collectClassShapeInner(decl));
+    if (lowerer.classes.has(lowerer.classNamer(decl)) ||
+        lowerer.collectingClassDeclarations.has(decl))
+        return;
+    lowerer.collectingClassDeclarations.add(decl);
+    try {
+        collectClassShapeDeferring(lowerer, decl);
+    }
+    finally {
+        lowerer.collectingClassDeclarations.delete(decl);
+    }
+}
+function collectClassShapeDeferring(lowerer, decl) {
+    const symbol = lowerer.collectDeferring(() => declSymbolOf(lowerer, decl), () => {
+        // A forward type reference can demand this class before collection
+        // reaches its earlier base declaration. Collect that dependency first;
+        // a later same-file base remains subject to the runtime order boundary.
+        const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+        const reference = heritage && ts.isPropertyAccessExpression(heritage) ? heritage.name : heritage;
+        const baseSymbol = reference && ts.isIdentifier(reference) ? lowerer.resolveValueSymbol(reference) : undefined;
+        const baseDeclaration = baseSymbol
+            ? lowerer.checker.declarationsOf(baseSymbol).find(ts.isClassDeclaration)
+            : undefined;
+        if (baseDeclaration &&
+            !lowerer.isStdlibSymbol(baseSymbol ?? undefined) &&
+            !baseDeclaration.getSourceFile().isDeclarationFile &&
+            (baseDeclaration.getSourceFile() !== decl.getSourceFile() ||
+                baseDeclaration.getStart() < decl.getStart()))
+            lowerer.collectClassShape(baseDeclaration);
+        lowerer.collectClassShapeInner(decl);
+    });
     // Typed receivers and module retention know the class only by its
     // qualified IR name — index the deferral under it too.
     if (symbol)
@@ -898,7 +1032,9 @@ export function collectClassShape(lowerer, decl) {
     }
 }
 function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
-    if (!ts.isNewExpression(initializer) || (initializer.arguments?.length ?? 0) !== 0 || !ts.isIdentifier(initializer.expression))
+    if (!ts.isNewExpression(initializer) ||
+        (initializer.arguments?.length ?? 0) !== 0 ||
+        !ts.isIdentifier(initializer.expression))
         return null;
     const collection = initializer.expression.text;
     if (collection !== "Map" && collection !== "Set")
@@ -912,7 +1048,11 @@ function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
     const mappedArgument = (argument) => {
         const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(argument));
         const mapped = lowerer.mapTypeOf(type);
-        if (!mapped || mapped.kind === "dyn" || mapped.kind === "jsval" || mapped.kind === "void" || isUnitType(mapped))
+        if (!mapped ||
+            mapped.kind === "dyn" ||
+            mapped.kind === "jsval" ||
+            mapped.kind === "void" ||
+            isUnitType(mapped))
             return null;
         return mapped;
     };
@@ -927,19 +1067,27 @@ function inferredEmptyCollectionFieldType(lowerer, decl, field, initializer) {
             receiver.name.text !== field) {
             return undefined;
         }
-        if (collection === "Map" && node.expression.name.text === "set" && node.arguments.length === 2) {
+        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, key.kind === "union" ? lowerer.unions.get(key.unionId)?.arms : undefined) && 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);
             }
         }
         if (collection === "Set" &&
-            (node.expression.name.text === "add" || node.expression.name.text === "has" || node.expression.name.text === "delete") &&
+            (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, element.kind === "union" ? lowerer.unions.get(element.unionId)?.arms : undefined))
+            if (element !== null &&
+                isSupportedSetElem(element, element.kind === "union" ? lowerer.unions.get(element.unionId)?.arms : undefined))
                 setElements.push(element);
         }
         return undefined;
@@ -1008,8 +1156,10 @@ mixin) {
                 // The guaranteed-throw SHELL: declarations only (expressions
                 // lower their throw at the expression — lowerClassExpression),
                 // never instantiations/mixins (they share a family declaration).
-                if (inst === undefined && mixin === undefined &&
-                    ts.isClassDeclaration(decl) && decl.typeParameters === undefined) {
+                if (inst === undefined &&
+                    mixin === undefined &&
+                    ts.isClassDeclaration(decl) &&
+                    decl.typeParameters === undefined) {
                     const thrown = guaranteedDecorationThrow(lowerer, decl);
                     if (thrown) {
                         const className = lowerer.classNamer(decl);
@@ -1055,9 +1205,9 @@ mixin) {
                         : ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)
                             ? "accessor decorators"
                             : ts.isPropertyDeclaration(member)
-                                ? (member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)
+                                ? member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)
                                     ? "auto-accessor decorators"
-                                    : "field decorators")
+                                    : "field decorators"
                                 : "member decorators";
                     lowerer.unsupported("SC1090", dec, `${kind} (the standard context object and member replacement have no static lowering — class decorators and provably-throwing ambient decorations compile)`);
                 }
@@ -1093,60 +1243,48 @@ mixin) {
             lowerer.unsupported("SC1090", decl, "generic class expressions");
         }
         const className = inst ? inst.name : mixin ? mixin.name : lowerer.classNamer(decl); // program-wide qualified name
-        // Single inheritance: `extends` of a class declared in the program.
-        // tsc guarantees the base is declared before the derived class (its
-        // use-before-declaration error), and collection runs in module order,
-        // 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.
+        // Collection follows module order for runtime heritage. Ordinary
+        // instances use the family as their storage base; generic heritage
+        // resolves a concrete base under each instance's type bindings.
         const computedBase = lowerer.computedClassBases.get(lowerer.classNamer(decl));
-        let base = inst ? inst.family : mixin ? mixin.base : computedBase?.classInfo ?? null;
+        let base = inst
+            ? inst.family
+            : mixin
+                ? mixin.base
+                : (computedBase?.classInfo ?? null);
+        let genericBase;
         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` };
+                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()) ||
+            if (!source ||
+                !isJsSourceFile(source.getSourceFile()) ||
                 !(ts.isFunctionDeclaration(source) || ts.isFunctionExpression(source)))
                 return false;
-            callableBase = { expression, constructorId: `%g.${className}.base`, prototypeId: `%g.${className}.basePrototype` };
+            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
-        // them. Named fence at the declaration.
-        if (familyMode && decl.heritageClauses !== undefined) {
-            const tpSyms = new Set();
-            for (const tp of decl.typeParameters) {
-                const s = lowerer.checker.getSymbolAtLocation(tp.name);
-                if (s)
-                    tpSyms.add(s);
-            }
-            for (const clause of decl.heritageClauses) {
-                if (clause.token !== ts.SyntaxKind.ExtendsKeyword)
-                    continue;
-                for (const t of clause.types) {
-                    let mentions = false;
-                    ts.walkPreorder(t, (n) => {
-                        const s = ts.isIdentifier(n) ? lowerer.checker.getSymbolAtLocation(n) : undefined;
-                        if (s && tpSyms.has(s)) {
-                            mentions = true;
-                            return "stop";
-                        }
-                        return undefined;
-                    });
-                    if (mentions) {
-                        lowerer.unsupported("SC1090", t, "generic classes whose 'extends' clause mentions their own type parameters (each instantiation would need a different base)");
-                    }
-                }
-            }
+        const ownGenericBase = inst?.family.genericBase;
+        if (inst && ownGenericBase) {
+            const mapped = lowerer.mapTypeOf(lowerer.checker.getTypeAtLocation(ownGenericBase));
+            base = mapped?.kind === "object" ? (lowerer.classes.get(mapped.className) ?? null) : null;
+            if (!base || base.generic)
+                lowerer.unsupported("SC1090", ownGenericBase, "a generic base whose type arguments have no concrete layout");
         }
         for (const clause of inst || mixin || computedBase ? [] : (decl.heritageClauses ?? [])) {
             // `implements` is pure type-world: tsc checked the conformance and
@@ -1156,6 +1294,22 @@ mixin) {
             if (clause.token === ts.SyntaxKind.ImplementsKeyword)
                 continue;
             const t = clause.types[0];
+            if (familyMode && t) {
+                const reference = ts.isPropertyAccessExpression(t.expression)
+                    ? t.expression.name
+                    : t.expression;
+                const symbol = ts.isIdentifier(reference)
+                    ? lowerer.resolveValueSymbol(reference)
+                    : undefined;
+                const familyBase = symbol ? lowerer.classBySymbol.get(symbol) : undefined;
+                if (familyBase?.generic) {
+                    if (symbol && ts.isPropertyAccessExpression(t.expression))
+                        fenceEarlyNsMemberRef(lowerer, t.expression, symbol);
+                    base = familyBase;
+                    genericBase = t;
+                    continue;
+                }
+            }
             // `extends events.EventEmitter` — the namespace-member spelling of
             // the ambient emitter base resolves like the named import.
             if (t && ts.isPropertyAccessExpression(t.expression) && ts.isIdentifier(t.expression.name)) {
@@ -1163,8 +1317,10 @@ 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;
+                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");
@@ -1231,8 +1387,7 @@ mixin) {
                     const rebinds = memberSym !== undefined &&
                         lowerer.checker
                             .declarationsOf(memberSym)
-                            .filter((d) => ts.isBinaryExpression(d) &&
-                            d.operatorToken.kind === ts.SyntaxKind.EqualsToken).length > 1;
+                            .filter((d) => ts.isBinaryExpression(d) && d.operatorToken.kind === ts.SyntaxKind.EqualsToken).length > 1;
                     if (rebinds) {
                         lowerer.unsupported("SC1090", t, `extending the reassigned property '${t.expression.getText()}' (the runtime base is whichever assignment ran last — bind the class exactly once)`);
                     }
@@ -1295,8 +1450,10 @@ mixin) {
             if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%DOMException") {
                 lowerer.unsupported("SC1090", t, "extending DOMException (its runtime layout carries hidden slots a subclass would overlap — extend Error and set name/code yourself)");
             }
-            const named = (symbol && lowerer.classBySymbol.get(symbol)) ?? lowerer.builtinErrorInfoOf(symbol) ??
-                lowerer.builtinEmitterInfoOf(symbol) ?? builtinStreamInfoOf(lowerer, symbol) ??
+            const named = (symbol && lowerer.classBySymbol.get(symbol)) ??
+                lowerer.builtinErrorInfoOf(symbol) ??
+                lowerer.builtinEmitterInfoOf(symbol) ??
+                builtinStreamInfoOf(lowerer, symbol) ??
                 // A const BINDING holding exactly one class (`const B = Animal`,
                 // `const B = class {…}`): the base is that class — extends
                 // through the alias is the declaration story (a general class
@@ -1314,7 +1471,8 @@ mixin) {
                 (() => {
                     const stored = storedClassValueType(lowerer, t.expression);
                     return stored?.kind === "classval" ? lowerer.classes.get(stored.className) : null;
-                })() ?? 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`).
@@ -1397,10 +1555,16 @@ mixin) {
         const runtimePrototypeMembers = [];
         // Public JS accessors need live constructor descriptors, including
         // receiver-sensitive getters and setters inherited by subclasses.
-        const checkedStatics = isJsSourceFile(decl.getSourceFile()) && (base && hasRuntimeStatics(base) || decl.members.some((member) => ts.isAccessor(member) && !ts.isPrivateIdentifier(member.name) &&
-            member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
-            !decl.members.some((member) => member.name && ts.isPrivateIdentifier(member.name) &&
-                ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
+        const checkedStatics = isJsSourceFile(decl.getSourceFile()) &&
+            ((base && hasRuntimeStatics(base)) ||
+                decl.members.some((member) => ts.isAccessor(member) &&
+                    !ts.isPrivateIdentifier(member.name) &&
+                    member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
+            !decl.members.some((member) => member.name &&
+                ts.isPrivateIdentifier(member.name) &&
+                ts
+                    .getModifiers(member)
+                    ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
         // GENERIC methods (own type parameters), instance and static: only
         // the SYNTAX is checked here — parameter/return types mention the
         // type parameters and cannot map yet; bodies lower per call-site
@@ -1436,7 +1600,9 @@ mixin) {
                 typeParams.push(sym);
             }
             for (const param of fnNode.parameters) {
-                if (!ts.isIdentifier(param.name) && !ts.isObjectBindingPattern(param.name) && !ts.isArrayBindingPattern(param.name)) {
+                if (!ts.isIdentifier(param.name) &&
+                    !ts.isObjectBindingPattern(param.name) &&
+                    !ts.isArrayBindingPattern(param.name)) {
                     lowerer.unsupported("SC1031", param);
                 }
             }
@@ -1449,16 +1615,23 @@ mixin) {
             });
         };
         for (const member of decl.members) {
-            if ((functionLocalClass(decl) || checkedStatics) && isJsSourceFile(decl.getSourceFile()) &&
-                (ts.isClassStaticBlockDeclaration(member) || ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) {
+            if ((functionLocalClass(decl) || checkedStatics) &&
+                isJsSourceFile(decl.getSourceFile()) &&
+                (ts.isClassStaticBlockDeclaration(member) ||
+                    ts
+                        .getModifiers(member)
+                        ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) {
                 runtimeStatics.push(member);
                 continue;
             }
-            if (functionLocalClass(decl) && isJsSourceFile(decl.getSourceFile()) &&
-                (ts.isMethodDeclaration(member) || ts.isAccessor(member)) && member.body &&
+            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)
+                if (ts.isComputedPropertyName(member.name) &&
+                    classMemberNameOf(lowerer, member.name) === null)
                     continue;
             }
             if (ts.isClassStaticBlockDeclaration(member)) {
@@ -1507,15 +1680,20 @@ mixin) {
                     (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                     member.initializer &&
                     member.postfixToken?.kind !== ts.SyntaxKind.QuestionToken) {
-                    const initializerSymbol = ts.isIdentifier(member.initializer) ? lowerer.resolveValueSymbol(member.initializer) : null;
+                    const initializerSymbol = ts.isIdentifier(member.initializer)
+                        ? lowerer.resolveValueSymbol(member.initializer)
+                        : null;
                     // Enum namespace aliases are erased; member reads fold through the checker.
                     if (initializerSymbol && (initializerSymbol.flags & ts.SymbolFlags.Enum) !== 0)
                         continue;
                     const type = lowerer.irTypeOf(member.name);
                     if (type.kind === "void")
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
-                    if (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile()) &&
-                        (member.type !== undefined || (lowerer.typeOf(member.name).flags & ts.TypeFlags.Any) === 0)) {
+                    if (type.kind === "dyn" &&
+                        !isJsSourceFile(member.getSourceFile()) &&
+                        !lowerer.classImplementedProtocol(lowerer.typeOf(member.name)) &&
+                        (member.type !== undefined ||
+                            (lowerer.typeOf(member.name).flags & ts.TypeFlags.Any) === 0)) {
                         lowerer.unsupported("SC1090", member.name, "'unknown'-typed static fields");
                     }
                     staticFields.push({
@@ -1538,14 +1716,19 @@ mixin) {
                         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) {
+                    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,
+                                decl: member,
+                                baseName: member.name.text,
                                 qualifiedName: `%${className}.static:${member.name.text}%implicit`,
-                                typeParams: [], instances: new Map(), implicitParams: implicit,
+                                typeParams: [],
+                                instances: new Map(),
+                                implicitParams: implicit,
                             });
                     }
                 }
@@ -1577,11 +1760,18 @@ mixin) {
             // (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 (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 });
+                    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");
@@ -1619,7 +1809,8 @@ mixin) {
             // keep the fence for emit too: the runtime stream machinery emits
             // 'data'/'end'/... internally, which could never route through
             // the override.
-            if (memberName && ts.isIdentifier(memberName) &&
+            if (memberName &&
+                ts.isIdentifier(memberName) &&
                 EMITTER_API_MEMBERS.has(memberName.text) &&
                 (() => {
                     for (let c = base; c; c = c.base)
@@ -1633,7 +1824,10 @@ mixin) {
                             return true;
                     return false;
                 })();
-                if (memberName.text === "emit" && !streamRooted && !inst && !mixin &&
+                if (memberName.text === "emit" &&
+                    !streamRooted &&
+                    !inst &&
+                    !mixin &&
                     ts.isMethodDeclaration(member) &&
                     !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
                     const reason = emitOverrideShapeReason(lowerer, member);
@@ -1698,20 +1892,39 @@ 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;
+                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()))) {
+                    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 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;
                     let type = mapped?.kind === "record" && isJsSourceFile(member.getSourceFile()) && !member.type
-                        ? DYN : mapped ? jsOpenObjectType(member, mapped, lowerer.shapes, lowerer.unions) : null;
-                    if (!type || type.kind === "void" || (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile())))
+                        ? DYN
+                        : mapped
+                            ? jsOpenObjectType(member, mapped, lowerer.shapes, lowerer.unions)
+                            : null;
+                    if (!type ||
+                        type.kind === "void" ||
+                        (type.kind === "dyn" &&
+                            !isJsSourceFile(member.getSourceFile()) &&
+                            !lowerer.classImplementedProtocol(inferred)))
                         lowerer.badType(member, inferred);
                     if (isJsSourceFile(member.getSourceFile())) {
                         type = inheritedJsFieldType(lowerer, decl, fieldName, type);
@@ -1729,11 +1942,22 @@ mixin) {
                         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 });
+                        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 } : {}) });
+                        fieldOrder.push({
+                            name: fieldName,
+                            type,
+                            initializer: member.initializer,
+                            ...(undefinedInitializer ? { undefinedInitializer } : {}),
+                        });
                     }
                     if (symbolKey)
                         symbolFields.set(symbolKey.identity, fieldName);
@@ -1788,20 +2012,28 @@ mixin) {
                 if (isJsSourceFile(member.getSourceFile()) && !member.initializer) {
                     const constructor = decl.members.find((part) => ts.isConstructorDeclaration(part) && !!part.body);
                     for (const statement of constructor?.body?.statements ?? []) {
-                        if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression) ||
+                        if (!ts.isExpressionStatement(statement) ||
+                            !ts.isBinaryExpression(statement.expression) ||
                             statement.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
                             continue;
                         const left = statement.expression.left;
-                        if (!ts.isPropertyAccessExpression(left) || left.expression.kind !== ts.SyntaxKind.ThisKeyword || left.name.text !== member.name.text)
+                        if (!ts.isPropertyAccessExpression(left) ||
+                            left.expression.kind !== ts.SyntaxKind.ThisKeyword ||
+                            left.name.text !== member.name.text)
                             continue;
-                        type = statement.expression.right.kind === ts.SyntaxKind.NullKeyword ? DYN : jsFieldInitializerType(lowerer, type, statement.expression.right);
+                        type =
+                            statement.expression.right.kind === ts.SyntaxKind.NullKeyword
+                                ? DYN
+                                : jsFieldInitializerType(lowerer, type, statement.expression.right);
                     }
                 }
                 // Unannotated JavaScript callback slots retain the original
                 // callable and its receiver instead of adapting its signature.
-                if (isJsSourceFile(member.getSourceFile()) && !member.type &&
+                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.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.
@@ -1820,7 +2052,9 @@ mixin) {
                 // 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())) {
+                if (type.kind === "dyn" &&
+                    !isJsSourceFile(member.getSourceFile()) &&
+                    !lowerer.classImplementedProtocol(lowerer.typeOf(member.name))) {
                     lowerer.unsupported("SC1090", member.name, "'unknown'-typed class fields");
                 }
                 const undefinedInitializer = type.kind === "dyn" && !member.initializer ? locOf(member) : undefined;
@@ -1838,7 +2072,13 @@ mixin) {
                     // Other bare or type-changing redeclarations keep the fence.
                     const baseType = fields.get(member.name.text);
                     if ((member.initializer || type.kind === "dyn") && typeEquals(type, baseType)) {
-                        fieldOrder.push({ name: member.name.text, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}), redeclared: true });
+                        fieldOrder.push({
+                            name: member.name.text,
+                            type,
+                            initializer: member.initializer,
+                            ...(undefinedInitializer ? { undefinedInitializer } : {}),
+                            redeclared: true,
+                        });
                         continue;
                     }
                     lowerer.unsupported("SC1090", member.name, member.initializer
@@ -1862,8 +2102,10 @@ mixin) {
                 // list checked against the constructor after the member loop
                 // (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 === "dyn";
+                    (lowerer.unions.get(type.unionId)?.arms.some((a) => a.kind === "undefinedT") ??
+                        false)) ||
+                    type.kind === "jsval" ||
+                    type.kind === "dyn";
                 if (!member.initializer && !admitsUndefined) {
                     const opts = lowerer.program.getCompilerOptions();
                     const spi = opts.strictPropertyInitialization ?? opts.strict ?? false;
@@ -1883,7 +2125,12 @@ mixin) {
                     }
                 }
                 fields.set(member.name.text, type);
-                fieldOrder.push({ name: member.name.text, type, initializer: member.initializer, ...(undefinedInitializer ? { undefinedInitializer } : {}) });
+                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,
@@ -1935,7 +2182,7 @@ mixin) {
                     if (type.kind === "void")
                         lowerer.badType(p.name, lowerer.typeOf(p.name));
                     // The class-field dyn rule verbatim (KEEP NARROW).
-                    if (type.kind === "dyn") {
+                    if (type.kind === "dyn" && !lowerer.classImplementedProtocol(lowerer.typeOf(p))) {
                         lowerer.unsupported("SC1090", p.name, "'unknown'-typed class fields");
                     }
                     // `override x` (and any same-named inherited member) would
@@ -2027,15 +2274,18 @@ mixin) {
                 // signature carries bindable untyped params collects like a
                 // GENERIC method — into genericMethods, no vtable slot, one
                 // instance per call-site type tuple (the untyped params ARE the
-                // type parameters; see lower-calls' implicit section). DECLINES
+                // type parameters; see generic-functions.ts). DECLINES
                 // (falls through to the normal all-dyn ABI) wherever the two
                 // 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()) && !functionLocalClass(decl) &&
+                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 &&
+                    !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)) {
@@ -2069,9 +2319,13 @@ mixin) {
                 }
                 // JS inference may retain only a symbol sentinel while a method
                 // also returns values from an untyped mutable field or local.
-                if (isJsSourceFile(member.getSourceFile()) && !member.type && !hasExplicitJsDocReturn(member) && ft.ret.kind === "symbol")
+                if (isJsSourceFile(member.getSourceFile()) &&
+                    !member.type &&
+                    !hasExplicitJsDocReturn(member) &&
+                    ft.ret.kind === "symbol")
                     ft.ret = DYN;
-                if (isJsSourceFile(member.getSourceFile()) && lowerer.prototypeMethodAccesses.has(mName) &&
+                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) {
@@ -2087,7 +2341,8 @@ mixin) {
                 // 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) &&
+                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" });
@@ -2121,13 +2376,18 @@ mixin) {
                     // 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)
+                    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)) &&
+                    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.
@@ -2136,8 +2396,13 @@ mixin) {
                     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" &&
+                        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 };
                         }
@@ -2147,12 +2412,18 @@ mixin) {
                 // 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()) &&
+                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" })));
+                    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 &&
                     member.asteriskToken === undefined &&
@@ -2160,7 +2431,8 @@ mixin) {
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
                         !typeEquals(overridden.sig.ret, ft.ret))) {
                     const fencedJsOverride = isJsSourceFile(member.getSourceFile()) &&
-                        overridden.declarer.decl !== null && isJsSourceFile(overridden.declarer.decl.getSourceFile()) &&
+                        overridden.declarer.decl !== null &&
+                        isJsSourceFile(overridden.declarer.decl.getSourceFile()) &&
                         overridden.sig.gen === undefined;
                     if (fencedJsOverride) {
                         // A dormant JS method must not poison the whole class. Keep
@@ -2171,8 +2443,11 @@ mixin) {
                             !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;
+                                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));
@@ -2201,7 +2476,8 @@ mixin) {
                     else
                         lowerer.unsupported("SC1090", member.name, message);
                 }
-                if (overridden && (member.asteriskToken !== undefined || overridden.sig.gen !== undefined)) {
+                if (overridden &&
+                    (member.asteriskToken !== undefined || overridden.sig.gen !== undefined)) {
                     const message = `overriding the generator method '${mName}' (generator methods dispatch statically — a virtual slot cannot enter their spawn wrapper)`;
                     if (isJsSourceFile(member.getSourceFile()))
                         methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), message));
@@ -2223,7 +2499,9 @@ mixin) {
                     });
                 }
                 else {
-                    methods.set(mName, asyncMember ? { params: shapes, ret: ft.ret, async: true } : { params: shapes, ret: ft.ret });
+                    methods.set(mName, asyncMember
+                        ? { params: shapes, ret: ft.ret, async: true }
+                        : { params: shapes, ret: ft.ret });
                 }
                 // Overrides keep the inherited ABI exactly, so only non-override
                 // methods may still refine once the ctor scan runs.
@@ -2262,14 +2540,19 @@ mixin) {
                 if (!member.body && !abstractAccessor)
                     lowerer.unsupported("SC1090", member, "bodyless accessors");
                 const mName = `${isGet ? "get" : "set"}:${prop}`;
-                if (fields.has(prop) && isJsSourceFile(decl.getSourceFile()) && base?.fields.has(prop) &&
+                if (fields.has(prop) &&
+                    isJsSourceFile(decl.getSourceFile()) &&
+                    base?.fields.has(prop) &&
                     !fieldOrder.some((field) => field.name === prop)) {
                     // JS may override an inherited data field with a prototype
                     // accessor. Retain the base storage prefix for its constructor;
                     // property dispatch on this subclass selects the accessor.
                     fields.delete(prop);
                 }
-                if (fields.has(prop) && !((prop === "message" || prop === "name") && base && (base.def.name === "%Error" || lowerer.isSubclassOf(base.def.name, "%Error")))) {
+                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");
                 }
@@ -2333,7 +2616,11 @@ mixin) {
         if (paramProps.length > 0) {
             for (const pp of paramProps)
                 fields.set(pp.name, pp.type);
-            fieldOrder.unshift(...paramProps.map((pp) => ({ name: pp.name, type: pp.type, initializer: undefined })));
+            fieldOrder.unshift(...paramProps.map((pp) => ({
+                name: pp.name,
+                type: pp.type,
+                initializer: undefined,
+            })));
         }
         // The deferred definite-assignment check: a field on the unguarded
         // list passes only with an unconditional `this.x = ...` at the
@@ -2367,9 +2654,14 @@ mixin) {
                 // extraction targets one arm); union-typed `!` fields keep the
                 // fence.
                 const declared = fields.get(f.name);
-                const armable = declared !== undefined && !isUnitType(declared) &&
-                    declared.kind !== "union" && declared.kind !== "jsval" && declared.kind !== "dyn" &&
-                    declared.kind !== "map" && declared.kind !== "date" && declared.kind !== "generator" &&
+                const armable = declared !== undefined &&
+                    !isUnitType(declared) &&
+                    declared.kind !== "union" &&
+                    declared.kind !== "jsval" &&
+                    declared.kind !== "dyn" &&
+                    declared.kind !== "map" &&
+                    declared.kind !== "date" &&
+                    declared.kind !== "generator" &&
                     declared.kind !== "void" &&
                     declared.kind !== "caught";
                 const armed = armable ? lowerer.withUndefinedArm(declared) : null;
@@ -2436,13 +2728,18 @@ 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}`) ||
+            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.
-            const classSym = decl.name ? lowerer.checker.getSymbolAtLocation(decl.name) : ts.isClassDeclaration(decl) ? declSymbolOf(lowerer, decl) : undefined;
+            const classSym = decl.name
+                ? lowerer.checker.getSymbolAtLocation(decl.name)
+                : ts.isClassDeclaration(decl)
+                    ? declSymbolOf(lowerer, decl)
+                    : undefined;
             const instType = classSym ? lowerer.checker.getDeclaredTypeOfSymbol(classSym) : undefined;
             // LATE-BOUND properties (the checker's `__@name@id` spelling —
             // `this[kLimit] = v` where kLimit is a unique symbol const) by
@@ -2466,7 +2763,8 @@ mixin) {
                         stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken
                         ? stmt.expression.left
                         : null;
-                    if (lhs && ts.isPropertyAccessExpression(lhs) &&
+                    if (lhs &&
+                        ts.isPropertyAccessExpression(lhs) &&
                         lhs.expression.kind === ts.SyntaxKind.ThisKeyword) {
                         const assign = lhs;
                         const name = assign.name.text;
@@ -2493,7 +2791,9 @@ 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()))
+                        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);
@@ -2540,7 +2840,8 @@ mixin) {
                     // property type, through the same JS checked-dynamic fallback
                     // as named fields. Keys that DON'T resolve fall through to the
                     // late-bound fence below.
-                    if (lhs && ts.isElementAccessExpression(lhs) &&
+                    if (lhs &&
+                        ts.isElementAccessExpression(lhs) &&
                         lhs.expression.kind === ts.SyntaxKind.ThisKeyword) {
                         const key = classSymbolKeyOf(lowerer, lhs.argumentExpression);
                         const stringKey = lowerer.foldedStringKeyOf(lhs.argumentExpression);
@@ -2566,7 +2867,11 @@ mixin) {
                             // one layout would need one printable name for two slots.
                             lowerer.unsupported("SC1090", lhs, `distinct symbol keys sharing the printable name '${symbolFieldDisplayName(fieldName)}' in one class`);
                         }
-                        const propSym = key ? lateBoundByKey.get(key.sym) : instType ? lowerer.checker.getPropertyOfType(instType, fieldName) : undefined;
+                        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
@@ -2610,7 +2915,10 @@ mixin) {
                     continue;
                 if (base && (base.fields.has(p.name) || lowerer.findMethodOn(base, p.name)))
                     continue;
-                const site = lowerer.checker.declarationsOf(p).find((d) => ts.isPropertyAccessExpression(d) || ts.isBinaryExpression(d) ||
+                const site = lowerer.checker
+                    .declarationsOf(p)
+                    .find((d) => ts.isPropertyAccessExpression(d) ||
+                    ts.isBinaryExpression(d) ||
                     ts.isElementAccessExpression(d));
                 if (!site)
                     continue;
@@ -2684,8 +2992,11 @@ mixin) {
         const ctorParams = ctor && !mixinForwarding
             ? lowerer.paramShapes(ctor.parameters)
             : (base?.ctorParams ?? (callableBase ? [{ type: DYN, mode: "dynRest" }] : []));
-        if (ctor && !mixinForwarding && isJsSourceFile(ctor.getSourceFile()) &&
-            !ctorParams.some((shape) => shape.mode === "rest" || shape.mode === "dynRest" || shape.mode === "islandRest") && bodyReadsArguments(ctor)) {
+        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 = {
@@ -2708,7 +3019,9 @@ mixin) {
                 // initializers assign the prefix slot).
                 fields: [
                     ...(base?.def.fields ?? []),
-                    ...fieldOrder.filter((f) => f.redeclared !== true).map((f) => ({ name: f.name, type: f.type })),
+                    ...fieldOrder
+                        .filter((f) => f.redeclared !== true)
+                        .map((f) => ({ name: f.name, type: f.type })),
                 ],
                 ...(methods.size > 0 ? { methods: [...methods.keys()] } : {}),
                 ...(abstractClass ? { abstract: true } : {}),
@@ -2729,6 +3042,7 @@ mixin) {
             ctorParams,
             ...(paramProps.length > 0 ? { paramProps } : {}),
             base,
+            ...(genericBase ? { genericBase } : {}),
             ...(callableBase ? { callableBase } : {}),
             ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
@@ -2738,7 +3052,9 @@ mixin) {
             ...(staticBlocks.length > 0 ? { staticBlocks } : {}),
             ...(symbolFields.size > 0 ? { symbolFields } : {}),
             ...(symbolMethods.size > 0 ? { symbolMethods } : {}),
-            ...(classDecoratorNodes.length > 0 ? { classDecorators: { nodes: classDecoratorNodes } } : {}),
+            ...(classDecoratorNodes.length > 0
+                ? { classDecorators: { nodes: classDecoratorNodes } }
+                : {}),
             ...(deferredInitFields.size > 0 ? { deferredInitFields } : {}),
         };
         // GENERIC members get their declaring-class backlink now that the
@@ -2756,6 +3072,7 @@ mixin) {
         }
         if (inst) {
             info.genericInstance = {
+                path: inst.path,
                 family: inst.family,
                 bindings: inst.bindings,
                 typeArgsText: inst.typeArgsText,
@@ -2793,14 +3110,29 @@ mixin) {
         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 });
+            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 });
+            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 });
+            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
@@ -2812,29 +3144,45 @@ mixin) {
         // classes fence at their use sites).
         const classSymbol = inst || mixin
             ? undefined
-            : decl.name ? lowerer.checker.getSymbolAtLocation(decl.name) : ts.isClassDeclaration(decl) ? declSymbolOf(lowerer, decl) : undefined;
+            : decl.name
+                ? lowerer.checker.getSymbolAtLocation(decl.name)
+                : ts.isClassDeclaration(decl)
+                    ? declSymbolOf(lowerer, decl)
+                    : undefined;
         if (classSymbol)
             lowerer.classBySymbol.set(classSymbol, info);
         // Static-field storage registers with the module's globals only
         // once the whole shape collected (a poisoned class never leaves a
         // half-registered global behind).
         for (const f of staticFields) {
-            lowerer.globalsList.push({ id: f.globalId, name: `${info.def.jsName ?? className}.${f.name}`, type: f.type, mutable: !f.readonly });
+            lowerer.globalsList.push({
+                id: f.globalId,
+                name: `${info.def.jsName ?? className}.${f.name}`,
+                type: f.type,
+                mutable: !f.readonly,
+            });
         }
     }
 }
 /** mapType's generic-class hook: the INSTANTIATION a concrete type
-   * reference (`Box<number>`) names — registered on first demand. The
-   * instance's NAME reserves its key before the shape collects, so
-   * self-referential layouts (`next: Box<T> | null`) re-enter here and
-   * take the name without recursing; a poisoned collection (a field type
-   * with no lowering under these bindings — the diagnostic carries the
-   * instantiation context) leaves the entry poisoned and the type
-   * 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. */
+ * reference (`Box<number>`) names — registered on first demand. The
+ * instance's NAME reserves its key before the shape collects, so
+ * self-referential layouts (`next: Box<T> | null`) re-enter here and
+ * take the name without recursing; a poisoned collection (a field type
+ * with no lowering under these bindings — the diagnostic carries the
+ * instantiation context) leaves the entry poisoned and the type
+ * 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, mapArgument) {
-    const gci = lowerer.genericClassByDecl.get(decl);
+    let gci = lowerer.genericClassByDecl.get(decl);
+    if (!gci && ts.isClassDeclaration(decl)) {
+        // A method signature can reference a generic class declared later in
+        // the same module. Resolve its family now rather than freezing the
+        // signature at the erased family layout for the rest of the build.
+        lowerer.collectClassShape(decl);
+        gci = lowerer.genericClassByDecl.get(decl);
+    }
     if (!gci) {
         // The family never collected (a deferred/poisoned declaration): the
         // pre-generics answer — the class's own name, unregistered, so dead
@@ -2856,7 +3204,9 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     const familyT = { kind: "object", className: gci.family.def.name };
     // The checker appends `this` (and outer type parameters) to
     // getTypeArguments — only the declaration's own count participates.
-    const args = lowerer.checker.getTypeArguments(ref).slice(0, gci.typeParams.length);
+    const args = lowerer.checker
+        .getTypeArguments(ref)
+        .slice(0, gci.typeParams.length);
     const mapped = [];
     if (args.length === gci.typeParams.length) {
         for (const a of args) {
@@ -2889,12 +3239,12 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
             lowerer.noteGenericClassInstanceDemand(existing.info);
         return existing.poisoned ? null : { kind: "object", className: existing.name };
     }
-    // The generic-fn cap, same rationale (polymorphic recursion through
-    // class fields would mint instances forever). mapType has no
-    // diagnostic channel — the family answer keeps the site compilable
-    // where the OBJECT itself is never touched; touched members fence.
-    if (gci.instances.size >= MAX_GENERIC_INSTANCES)
-        return familyT;
+    // Recursive class fields and queued member bodies share the function
+    // demand budget. Independent uses do not limit the family size.
+    const path = extendInstantiationPath(lowerer.genericInstantiationPath, decl);
+    if (!path) {
+        lowerer.unsupported("SC1090", decl, `unbounded generic class instantiation ('${gci.baseName}' exceeded ${MAX_INSTANTIATION_RECURSION} recursive specializations on one demand path)`);
+    }
     const ordinal = gci.instances.size;
     const name = `${gci.family.def.name}%${ordinal}`;
     const entry = { name, info: null };
@@ -2905,10 +3255,19 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`;
     const prevBindings = lowerer.typeParamBindings;
     const prevContext = lowerer.instantiationContext;
+    const previousPath = lowerer.genericInstantiationPath;
+    lowerer.genericInstantiationPath = path;
     lowerer.typeParamBindings = bindings;
     lowerer.instantiationContext = `instantiating class '${gci.baseName}' with ${typeArgsText}`;
     try {
-        lowerer.collectClassShapeInner(decl, undefined, { family: gci.family, name, bindings, typeArgsText, ordinal });
+        lowerer.collectClassShapeInner(decl, undefined, {
+            path,
+            family: gci.family,
+            name,
+            bindings,
+            typeArgsText,
+            ordinal,
+        });
     }
     catch (e) {
         // Collection fenced under THESE bindings: the diagnostic (with the
@@ -2921,6 +3280,7 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     finally {
         lowerer.typeParamBindings = prevBindings;
         lowerer.instantiationContext = prevContext;
+        lowerer.genericInstantiationPath = previousPath;
     }
     const info = lowerer.classes.get(name);
     if (!info) {
@@ -2934,11 +3294,11 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     return { kind: "object", className: name };
 }
 /** Runs a member-lowering thunk under an INSTANTIATION's type-parameter
-   * bindings (the generic-fn typeParamResolver mechanism) — the checker
-   * keeps reporting the unsubstituted `T`s inside the shared body AST.
-   * Coverage counts a generic class's statements once: only the FIRST
-   * instantiation contributes (the lowerGenericInstance rule). A no-op
-   * for ordinary classes. */
+ * bindings (the generic-fn typeParamResolver mechanism) — the checker
+ * keeps reporting the unsubstituted `T`s inside the shared body AST.
+ * Coverage counts a generic class's statements once: only the FIRST
+ * instantiation contributes (the lowerGenericInstance rule). A no-op
+ * for ordinary classes. */
 function withInstanceBindings(lowerer, info, fn) {
     const gi = info.genericInstance;
     if (!gi) {
@@ -2970,6 +3330,8 @@ function withInstanceBindings(lowerer, info, fn) {
     const prevBindings = lowerer.typeParamBindings;
     const prevContext = lowerer.instantiationContext;
     const prevSuppress = lowerer.suppressStats;
+    const previousPath = lowerer.genericInstantiationPath;
+    lowerer.genericInstantiationPath = gi.path;
     lowerer.typeParamBindings = gi.bindings;
     lowerer.instantiationContext = `instantiating class '${gi.family.generic?.baseName ?? info.def.jsName ?? ""}' with ${gi.typeArgsText}`;
     lowerer.suppressStats = prevSuppress || gi.ordinal > 0;
@@ -2980,14 +3342,15 @@ function withInstanceBindings(lowerer, info, fn) {
         lowerer.typeParamBindings = prevBindings;
         lowerer.instantiationContext = prevContext;
         lowerer.suppressStats = prevSuppress;
+        lowerer.genericInstantiationPath = previousPath;
     }
 }
 /** The `%init` statements for one class's static readonly fields AND
-   * static blocks, interleaved in member order — emitted at the class
-   * statement's source position (see lowerFileInit's merge), exactly when
-   * JS evaluates static initializers and blocks. Field failures poison per
-   * field, like fieldInitStmts; a block lowers as the block statement it
-   * is, so its statements poison individually inside lowerStmts. */
+ * static blocks, interleaved in member order — emitted at the class
+ * statement's source position (see lowerFileInit's merge), exactly when
+ * JS evaluates static initializers and blocks. Field failures poison per
+ * 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 [];
@@ -3018,41 +3381,102 @@ 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;
+    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: [
+        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 });
+                ],
+                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: [
+        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 });
+                    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)
+        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 });
+                : 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: [
+        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 });
+                ],
+                type: DYN,
+                loc,
+            },
+            loc,
+        });
     }
     if (info.runtimeStatics && !info.localClass && info.decl) {
-        out.push({ kind: "exprStmt", expr: initializeRuntimeStatics(lowerer, info, classValueRef(lowerer, info, info.decl)), loc: locOf(info.decl) });
+        out.push({
+            kind: "exprStmt",
+            expr: initializeRuntimeStatics(lowerer, info, classValueRef(lowerer, info, info.decl)),
+            loc: locOf(info.decl),
+        });
     }
     const items = [
         ...info.staticFields.map((f) => ({ pos: f.initializer.getStart(), kind: "field", f })),
@@ -3072,11 +3496,24 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         try {
             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;
+                ? 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) });
+                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 {
@@ -3095,7 +3532,9 @@ function lowerStaticFieldInitsInner(lowerer, info) {
             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" });
+                const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, {
+                    kind: "statement",
+                });
                 if (fence)
                     out.push(fence);
             }
@@ -3104,22 +3543,22 @@ function lowerStaticFieldInitsInner(lowerer, info) {
     return out;
 }
 /** Post-collection analysis of a decorated class (all shapes registered —
-   * a decorator's return type may name a subclass declared BELOW the
-   * class). Classifies every class-level decorator by its checker type:
-   * exactly one parameter, itself a classval the decorated class legally
-   * flows into (the class, or a base sharing its completed constructor
-   * ABI — the classval widening rule), returning void/undefined (an
-   * effect-only decorator) or the class/a same-ABI subclass (a REPLACING
-   * decorator, whose result rebinds the name). Everything else is a named
-   * fence: the standard context parameter, structural sibling
-   * replacements tsc admits but the nominal classval world cannot carry,
-   * unions mixing the class with undefined. A replacing decorator
-   * registers the mutable classval global the name rebinds through, and
-   * fences the two shapes the value rebinding cannot keep exact —
-   * subclasses of the decorated class (the compiled hierarchy is fixed at
-   * build time; the runtime base would be the decoration result) and
-   * namespace-nested declarations (qualified references resolve the class
-   * directly, not through the rebound value). */
+ * a decorator's return type may name a subclass declared BELOW the
+ * class). Classifies every class-level decorator by its checker type:
+ * exactly one parameter, itself a classval the decorated class legally
+ * flows into (the class, or a base sharing its completed constructor
+ * ABI — the classval widening rule), returning void/undefined (an
+ * effect-only decorator) or the class/a same-ABI subclass (a REPLACING
+ * decorator, whose result rebinds the name). Everything else is a named
+ * fence: the standard context parameter, structural sibling
+ * replacements tsc admits but the nominal classval world cannot carry,
+ * unions mixing the class with undefined. A replacing decorator
+ * registers the mutable classval global the name rebinds through, and
+ * fences the two shapes the value rebinding cannot keep exact —
+ * subclasses of the decorated class (the compiled hierarchy is fixed at
+ * build time; the runtime base would be the decoration result) and
+ * namespace-nested declarations (qualified references resolve the class
+ * directly, not through the rebound value). */
 export function analyzeClassDecoration(lowerer, info) {
     const cd = info.classDecorators;
     if (!cd || cd.shapes !== undefined || cd.poisoned)
@@ -3237,14 +3676,14 @@ export function analyzeClassDecoration(lowerer, info) {
     }
 }
 /** The decoration statements of a decorated class — the %init code that
-   * runs at the class statement's position, BEFORE its static field
-   * initializers and blocks (lowerStaticFieldInits composes them; the
-   * lower-modules interleave places the whole bundle). Verified Node
-   * order: decorator expressions evaluate in SOURCE order (factories run
-   * here), then applications run in REVERSE member order over the class
-   * object, each replacing decorator's non-undefined result feeding the
-   * next application; the final value binds the class name (the mutable
-   * classval global) when any decorator can replace. */
+ * runs at the class statement's position, BEFORE its static field
+ * initializers and blocks (lowerStaticFieldInits composes them; the
+ * lower-modules interleave places the whole bundle). Verified Node
+ * order: decorator expressions evaluate in SOURCE order (factories run
+ * here), then applications run in REVERSE member order over the class
+ * object, each replacing decorator's non-undefined result feeding the
+ * next application; the final value binds the class name (the mutable
+ * classval global) when any decorator can replace. */
 function lowerClassDecoration(lowerer, info) {
     const cd = info.classDecorators;
     if (!cd || cd.poisoned || cd.shapes === undefined || info.decl === null)
@@ -3264,7 +3703,11 @@ function lowerClassDecoration(lowerer, info) {
             const d = cd.nodes[i];
             const shape = cd.shapes[i];
             if (shape.kind === "ambientThrow") {
-                stmts.push({ kind: "exprStmt", expr: nsUndefRead(lowerer, shape.name, d, F64), loc: locOf(d) });
+                stmts.push({
+                    kind: "exprStmt",
+                    expr: nsUndefRead(lowerer, shape.name, d, F64),
+                    loc: locOf(d),
+                });
                 return stmts;
             }
             const value = lowerer.lowerExprExpecting(d.expression, shape.funcType);
@@ -3313,9 +3756,9 @@ function lowerClassDecoration(lowerer, info) {
     }
 }
 /** The nearest declaration of static member `name` at or above `info` —
-   * the compile-time prototype-chain walk (`D.x` reads C's global when C
-   * declared x and nothing between redeclares it; a redeclaration shadows
-   * with its OWN storage, exactly JS). */
+ * the compile-time prototype-chain walk (`D.x` reads C's global when C
+ * declared x and nothing between redeclares it; a redeclaration shadows
+ * with its OWN storage, exactly JS). */
 export function findStaticOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const field = c.staticFields.find((s) => s.name === name);
@@ -3328,17 +3771,17 @@ export function findStaticOn(lowerer, info, name) {
     return null;
 }
 /** True when some STRICT descendant of `info` redeclares static `name` —
-   * the through-a-VALUE devirtualization test: a classval(info) slot can
-   * hold any descendant, and a shadowing redeclaration means the runtime
-   * class decides which storage answers. */
-export function staticShadowBelow(lowerer, info, name) {
+ * the through-a-VALUE devirtualization test: a classval(info) slot can
+ * hold any descendant, and a shadowing redeclaration means the runtime
+ * class decides which storage answers. */
+export function staticShadowBelow(info, name) {
     return info.subclasses.some((s) => s.staticFields.some((f) => f.name === name) ||
         s.staticMethods?.has(name) === true ||
         s.genericStatics?.has(name) === true ||
-        staticShadowBelow(lowerer, s, name));
+        staticShadowBelow(s, name));
 }
 /** The nearest GENERIC static declaration of `name` at/above `info` —
-   * findStaticOn's twin over the genericStatics tables. */
+ * findStaticOn's twin over the genericStatics tables. */
 export function findGenericStaticOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const gs = c.genericStatics?.get(name);
@@ -3348,8 +3791,8 @@ export function findGenericStaticOn(lowerer, info, name) {
     return null;
 }
 /** A static METHOD taken as a value: the zero-capture closure over its
-   * module function — the declared-function-as-value rule verbatim
-   * (interned by the backend, so `C.m === C.m` holds). */
+ * module function — the declared-function-as-value rule verbatim
+ * (interned by the backend, so `C.m === C.m` holds). */
 function staticMethodValue(lowerer, declarer, name, sig, blame, loc) {
     const reflected = reflectedClassStaticMethodValue(lowerer, declarer, name);
     if (reflected)
@@ -3366,13 +3809,13 @@ function staticMethodValue(lowerer, declarer, name, sig, blame, loc) {
     return { kind: "closure", fnName, captures: [], type: funcType, loc };
 }
 /** The class itself taken as a VALUE (`const X = C`, an argument, an
-   * array element, a class expression's result): the classRef over the
-   * per-class immortal class object. The construct thunk needs a thunk-
-   * shaped constructor, so classes whose construction is libCall-shaped —
-   * the runtime-provided builtins and anything inheriting a builtin
-   * constructor (Error/EventEmitter/stream chains complete their `new`
-   * by special rules) — are named fences here. The constructor edge is
-   * noted at every classRef: a value can always be constructed through. */
+ * array element, a class expression's result): the classRef over the
+ * per-class immortal class object. The construct thunk needs a thunk-
+ * shaped constructor, so classes whose construction is libCall-shaped —
+ * the runtime-provided builtins and anything inheriting a builtin
+ * constructor (Error/EventEmitter/stream chains complete their `new`
+ * by special rules) — are named fences here. The constructor edge is
+ * noted at every classRef: a value can always be constructed through. */
 export function classValueRef(lowerer, info, blame) {
     const display = info.def.name.replace(/^%|^%m\d+\./, "");
     fenceDecorationThrows(lowerer, info, blame);
@@ -3395,9 +3838,12 @@ export function classValueRef(lowerer, info, blame) {
     }
     if (lowerer.inheritsBuiltinEmitterCtor(info) ||
         inheritsBuiltinStreamCtor(lowerer, info) ||
-        (() => { for (let c = info.base; c; c = c.base)
-            if (c.builtinEmitter || c.builtinStream !== undefined)
-                return true; return false; })()) {
+        (() => {
+            for (let c = info.base; c; c = c.base)
+                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)`);
     }
     lowerer.noteEdge(`%${info.def.name}.constructor`);
@@ -3409,20 +3855,22 @@ export function classValueRef(lowerer, info, blame) {
     };
 }
 /** Constructor-ABI equality — the classval widening rule: a classval(D)
-   * value may flow into a classval(C) slot only when D's completed
-   * constructor signature equals C's (same count, modes, and ABI types),
-   * which is what keeps newValue completion against C's one signature
-   * sound for every value legally in the slot. */
+ * value may flow into a classval(C) slot only when D's completed
+ * constructor signature equals C's (same count, modes, and ABI types),
+ * which is what keeps newValue completion against C's one signature
+ * sound for every value legally in the slot. */
 export function ctorAbiEquals(lowerer, sub, sup) {
     const a = sub.ctorParams;
     const b = sup.ctorParams;
-    return a.length === b.length && a.every((p, i) => p.mode === b[i].mode && typeEquals(p.type, b[i].type));
+    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))
+    if (access.questionDotToken ||
+        (!ts.isIdentifier(access.expression) && access.expression.kind !== ts.SyntaxKind.ThisKeyword))
         return null;
     const info = lowerer.exactClassOfReceiver(access.expression);
     if (!info)
@@ -3439,20 +3887,23 @@ export function staticFieldWriteTarget(lowerer, access) {
     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
-   * compile-time name. Null for everything else — unresolved members
-   * fall through to the ordinary chain so the static fence or the
-   * generic member rejection names the site. */
+ * member of its chain: field reads are the module global, static
+ * methods become interned closures, and `.name` folds to the class's
+ * compile-time name. Null for everything else — unresolved members
+ * fall through to the ordinary chain so the static fence or the
+ * generic member rejection names the site. */
 export function lowerStaticFieldRead(lowerer, expr) {
     if (expr.name.text === "prototype")
         return null;
     if (expr.questionDotToken)
         return null;
-    if (!ts.isIdentifier(expr.expression) && expr.expression.kind !== ts.SyntaxKind.ThisKeyword &&
+    if (!ts.isIdentifier(expr.expression) &&
+        expr.expression.kind !== ts.SyntaxKind.ThisKeyword &&
         exactClassOfReceiver(lowerer, expr.expression) === null)
         return null;
-    const symbol = ts.isIdentifier(expr.expression) ? lowerer.resolveValueSymbol(expr.expression) : null;
+    const 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,
@@ -3473,8 +3924,13 @@ export function lowerStaticFieldRead(lowerer, expr) {
     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 };
+        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
@@ -3503,25 +3959,38 @@ export function lowerStaticFieldRead(lowerer, expr) {
         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 };
+        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) {
-        const value = { kind: "dynKeyGet", value: data, key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc };
+        const value = {
+            kind: "dynKeyGet",
+            value: data,
+            key: { kind: "strLit", value: expr.name.text, type: STRING, loc },
+            type: DYN,
+            loc,
+        };
         // JavaScript often assigns public statics after the class declaration.
         // Their storage stays mutable and checked, while reads retain the
         // checker's concrete type instead of losing the method receiver.
-        const type = isJsSourceFile(expr.getSourceFile()) ? null : lowerer.mapTypeOf(lowerer.typeOf(expr));
+        const type = isJsSourceFile(expr.getSourceFile())
+            ? null
+            : lowerer.mapTypeOf(lowerer.typeOf(expr));
         return type ? lowerer.coerceToExpected(value, type) : value;
     }
     return null;
 }
 /** NamedEvaluation's answer for a class expression's `.name`: its own
-   * declared name, else the binding name when the expression is the
-   * direct initializer of a variable declaration / the RHS of a simple
-   * assignment / an object-literal property value / a default parameter —
-   * "" everywhere else (array elements, call arguments). Verified against
-   * Node for each shape. */
+ * declared name, else the binding name when the expression is the
+ * direct initializer of a variable declaration / the RHS of a simple
+ * assignment / an object-literal property value / a default parameter —
+ * "" everywhere else (array elements, call arguments). Verified against
+ * Node for each shape. */
 function namedEvaluationName(expr) {
     if (expr.name)
         return expr.name.text;
@@ -3530,7 +3999,9 @@ function namedEvaluationName(expr) {
         p = p.parent;
     if (ts.isVariableDeclaration(p) && ts.isIdentifier(p.name) && p.initializer !== undefined)
         return p.name.text;
-    if (ts.isBinaryExpression(p) && p.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(p.left))
+    if (ts.isBinaryExpression(p) &&
+        p.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isIdentifier(p.left))
         return p.left.text;
     if (ts.isPropertyAssignment(p) && ts.isIdentifier(p.name))
         return p.name.text;
@@ -3567,19 +4038,28 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     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)))) {
+    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))) {
+        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)) {
+            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")
@@ -3601,7 +4081,10 @@ export function lowerClassExpressionInfo(lowerer, expr) {
         throw new PoisonError(); // collection poisoned and reported
     if (local) {
         info.def.localCaptures = [];
-        info.def.fields.push({ name: `%classEnvironment:${info.def.name}`, type: { kind: "classval", className: info.def.name } });
+        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;
@@ -3619,10 +4102,17 @@ 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 (!local && (info.callableBase || info.def.baseValueGlobal || info.runtimeStatics || info.staticFields.length > 0 || (info.staticBlocks?.length ?? 0) > 0)) {
+    if (!local &&
+        (info.callableBase ||
+            info.def.baseValueGlobal ||
+            info.runtimeStatics ||
+            info.staticFields.length > 0 ||
+            (info.staticBlocks?.length ?? 0) > 0)) {
         let holder = expr.parent;
-        while (ts.isParenthesizedExpression(holder) || ts.isClassExpression(holder) ||
-            ts.isHeritageClause(holder) || ts.isExpressionWithTypeArguments(holder)) {
+        while (ts.isParenthesizedExpression(holder) ||
+            ts.isClassExpression(holder) ||
+            ts.isHeritageClause(holder) ||
+            ts.isExpressionWithTypeArguments(holder)) {
             holder = holder.parent;
         }
         const wholeInit = (ts.isVariableDeclaration(holder) &&
@@ -3643,13 +4133,13 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     return info;
 }
 /** `class {…}` in expression position: a class definition bound to no
-   * statement — once the static side is a value, the expression IS the
-   * definition plus a classRef over it. A DECORATED class expression
-   * whose decoration provably throws (the ambient-decorator shape) never
-   * mints a class at all: evaluating the expression IS the
-   * ReferenceError, so it lowers to exactly that read — every evaluation
-   * throws identically, which is why the once-evaluated restriction and
-   * the member fences don't apply. */
+ * statement — once the static side is a value, the expression IS the
+ * definition plus a classRef over it. A DECORATED class expression
+ * whose decoration provably throws (the ambient-decorator shape) never
+ * mints a class at all: evaluating the expression IS the
+ * ReferenceError, so it lowers to exactly that read — every evaluation
+ * throws identically, which is why the once-evaluated restriction and
+ * the member fences don't apply. */
 export function lowerClassExpression(lowerer, expr) {
     if (decoratorNodesOf(expr).length > 0 ||
         expr.members.some((m) => decoratorNodesOf(m).length > 0)) {
@@ -3664,8 +4154,13 @@ export function lowerClassExpression(lowerer, expr) {
         }
     }
     const info = lowerClassExpressionInfo(lowerer, expr);
-    if (!info.localClass && !info.expressionInitializationEmitted &&
-        (info.callableBase || info.def.baseValueGlobal || info.runtimeStatics || info.staticFields.length > 0 || (info.staticBlocks?.length ?? 0) > 0)) {
+    if (!info.localClass &&
+        !info.expressionInitializationEmitted &&
+        (info.callableBase ||
+            info.def.baseValueGlobal ||
+            info.runtimeStatics ||
+            info.staticFields.length > 0 ||
+            (info.staticBlocks?.length ?? 0) > 0)) {
         info.expressionInitializationEmitted = true;
         lowerer.pendingClassExprInits.push(...lowerer.lowerStaticFieldInits(info));
     }
@@ -3681,7 +4176,11 @@ export function lowerClassExpression(lowerer, expr) {
             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.def.localCaptures.push({
+                    localId: "%base",
+                    name: "base",
+                    type: { kind: "classval", className: info.base.def.name },
+                });
             }
             info.localClass.ready = true;
             lowerer.onExprClassCollected?.(info);
@@ -3701,18 +4200,47 @@ export function lowerClassExpression(lowerer, expr) {
         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: [
+        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: "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 });
+                        ],
+                        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 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);
@@ -3720,26 +4248,57 @@ export function lowerClassExpression(lowerer, expr) {
         const clsRef = { kind: "varRef", localId: clsLocal.id, type: value.type, loc };
         const basePrototype = classPrototypeData(lowerer, info.base, loc, baseRef);
         info.localPrototypeData = true;
-        return initializeRuntimeStatics(lowerer, info, { kind: "seqExpr", stmts: [
+        return initializeRuntimeStatics(lowerer, info, {
+            kind: "seqExpr",
+            stmts: [
                 { kind: "varDecl", localId: baseLocal.id, init: base, loc },
-                { kind: "varDecl", localId: clsLocal.id, init: { ...value, captures: [...info.localClass.captureSources, baseLocal.id] }, loc },
-                { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classInherit", args: [
-                            { kind: "dynFrom", value: clsRef, type: DYN, loc }, { kind: "dynFrom", value: baseRef, type: DYN, loc },
-                        ], type: DYN, loc }, loc },
-                { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.classPrototype", args: [
-                            { kind: "dynFrom", value: clsRef, type: DYN, loc }, basePrototype,
-                        ], type: DYN, loc }, loc },
-            ], result: clsRef, type: value.type, loc });
-    }
-    return info.localClass ? initializeRuntimeStatics(lowerer, info, value.kind === "classRef"
-        ? { ...value, captures: info.localClass.captureSources } : value) : value;
+                {
+                    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 info.localClass
+        ? initializeRuntimeStatics(lowerer, info, value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value)
+        : value;
 }
 /** The EXACT class a receiver expression is statically known to BE (not
-   * merely be typed by): the class name itself, or a `const` binding
-   * whose initializer is a class expression / class name. Such receivers
-   * can never hold a subclass at runtime, so static WRITES through them
-   * hit the declaring class's storage exactly (the shadowing hazards of
-   * general class values don't arise). Null for everything else. */
+ * merely be typed by): the class name itself, or a `const` binding
+ * whose initializer is a class expression / class name. Such receivers
+ * can never hold a subclass at runtime, so static WRITES through them
+ * hit the declaring class's storage exactly (the shadowing hazards of
+ * general class values don't arise). Null for everything else. */
 export function exactClassOfReceiver(lowerer, expr) {
     if (ts.isPropertyAccessExpression(expr) && !expr.questionDotToken) {
         const member = nsMemberIdentOf(lowerer, expr);
@@ -3750,7 +4309,9 @@ export function exactClassOfReceiver(lowerer, expr) {
     // 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;
+        return receiver?.type.kind === "classval"
+            ? (lowerer.classes.get(receiver.type.className) ?? null)
+            : null;
     }
     if (!ts.isIdentifier(expr))
         return null;
@@ -3765,7 +4326,9 @@ export function exactClassOfReceiver(lowerer, expr) {
     if (direct)
         return direct.classDecorators?.valueGlobalId !== undefined ? null : direct;
     const decl = lowerer.checker.valueDeclarationOf(symbol);
-    if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined ||
+    if (!decl ||
+        !ts.isVariableDeclaration(decl) ||
+        decl.initializer === undefined ||
         !ts.isVariableDeclarationList(decl.parent) ||
         (decl.parent.flags & ts.NodeFlags.Const) === 0) {
         return null;
@@ -3785,20 +4348,20 @@ export function exactClassOfReceiver(lowerer, expr) {
     return null;
 }
 /** The class a PROPERTY-ASSIGNMENT binding pins — the salsa/CJS
-   * declaration forms of a class expression: `Common.I = class {…}`
-   * (expando members of a plain object), `exports.I = class {…}` /
-   * `module.exports.I = class {…}` (CJS member exports), and
-   * `module.exports = class {…}` (the whole-export replacement, whose
-   * export symbol requirer bindings alias to). The symbol arrives in two
-   * shapes — an ALIAS resolving to the class expression's own symbol
-   * (valueDeclaration IS the ts.ClassExpression), or the expando property
-   * symbol whose declarations are the assignment BinaryExpressions — and
-   * both pin the class exactly when ONE top-level assignment declares it:
-   * a reassigned property is a dynamic binding (the runtime class is
-   * whichever assignment ran last), so it answers null and the caller's
-   * fence names it. Collection is on demand and idempotent
-   * (lowerClassExpressionInfo), so resolution order between files and
-   * passes never matters. */
+ * declaration forms of a class expression: `Common.I = class {…}`
+ * (expando members of a plain object), `exports.I = class {…}` /
+ * `module.exports.I = class {…}` (CJS member exports), and
+ * `module.exports = class {…}` (the whole-export replacement, whose
+ * export symbol requirer bindings alias to). The symbol arrives in two
+ * shapes — an ALIAS resolving to the class expression's own symbol
+ * (valueDeclaration IS the ts.ClassExpression), or the expando property
+ * symbol whose declarations are the assignment BinaryExpressions — and
+ * both pin the class exactly when ONE top-level assignment declares it:
+ * a reassigned property is a dynamic binding (the runtime class is
+ * whichever assignment ran last), so it answers null and the caller's
+ * fence names it. Collection is on demand and idempotent
+ * (lowerClassExpressionInfo), so resolution order between files and
+ * passes never matters. */
 export function propertyAssignedClassInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
@@ -3840,22 +4403,25 @@ export function propertyAssignedClassInfoOf(lowerer, symbol) {
     return info;
 }
 /** The top-level `… = <this class expression>` assignment a class
-   * expression is the (paren-unwrapped) RHS of, or null. */
+ * expression is the (paren-unwrapped) RHS of, or null. */
 function enclosingTopLevelClassAssignment(expr) {
     let value = expr;
     while (ts.isParenthesizedExpression(value.parent))
         value = value.parent;
     const p = value.parent;
-    if (!ts.isBinaryExpression(p) || p.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
-        p.right !== value || !ts.isExpressionStatement(p.parent) || !ts.isSourceFile(p.parent.parent)) {
+    if (!ts.isBinaryExpression(p) ||
+        p.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+        p.right !== value ||
+        !ts.isExpressionStatement(p.parent) ||
+        !ts.isSourceFile(p.parent.parent)) {
         return null;
     }
     return p;
 }
 /** How many top-level statements of the file assign the same target as
-   * `assign` (textual LHS match — `module.exports`, `exports.I`,
-   * `Common.I`): a second assignment makes the binding dynamic, so
-   * callers refuse to pin the first one's class. */
+ * `assign` (textual LHS match — `module.exports`, `exports.I`,
+ * `Common.I`): a second assignment makes the binding dynamic, so
+ * callers refuse to pin the first one's class. */
 function countAssignmentsTo(assign) {
     const sf = assign.getSourceFile();
     // `exports.I` and `module.exports.I` are the SAME binding in Node
@@ -3871,7 +4437,8 @@ function countAssignmentsTo(assign) {
         if (!ts.isExpressionStatement(stmt))
             continue;
         const e = stmt.expression;
-        if (ts.isBinaryExpression(e) && e.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        if (ts.isBinaryExpression(e) &&
+            e.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
             canon(e.left) === target) {
             n++;
         }
@@ -3879,14 +4446,14 @@ function countAssignmentsTo(assign) {
     return n;
 }
 /** `C.m(args)` / `X.m(args)` — static method calls, on the class name
-   * directly or through a class VALUE. Resolution walks the chain
-   * (nearest declarer, the compile-time prototype chain); through a
-   * VALUE the call devirtualizes exactly when no strict descendant
-   * redeclares the member (values never leave the static class's
-   * subtree). A func-typed static FIELD in call position reads the
-   * global and calls through the value. Null when the receiver isn't a
-   * class name/value or the member doesn't resolve (the fences name the
-   * site downstream). */
+ * directly or through a class VALUE. Resolution walks the chain
+ * (nearest declarer, the compile-time prototype chain); through a
+ * VALUE the call devirtualizes exactly when no strict descendant
+ * redeclares the member (values never leave the static class's
+ * subtree). A func-typed static FIELD in call position reads the
+ * global and calls through the value. Null when the receiver isn't a
+ * class name/value or the member doesn't resolve (the fences name the
+ * site downstream). */
 export function lowerStaticMethodCall(lowerer, call, access) {
     if (access.questionDotToken)
         return null;
@@ -3896,11 +4463,25 @@ export function lowerStaticMethodCall(lowerer, call, access) {
         if (info)
             return staticCallOn(lowerer, call, access, info, false);
     }
+    // Namespace exports are immutable bindings to the same declaration as
+    // named imports. Resolve them before asking for a constructor-value ABI:
+    // a generic family has statics but no single constructor signature.
+    if (ts.isPropertyAccessExpression(access.expression) && !access.expression.questionDotToken) {
+        const member = nsMemberIdentOf(lowerer, access.expression);
+        const symbol = member ? lowerer.resolveValueSymbol(member) : null;
+        const info = symbol ? lowerer.classBySymbol.get(symbol) : undefined;
+        if (info && info.classDecorators?.valueGlobalId === undefined) {
+            if (symbol)
+                fenceEarlyNsMemberRef(lowerer, access.expression, symbol);
+            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(), lowerer.program)) {
+        if (!isModuleExportsAccess(access.expression) ||
+            !isCjsJsFile(access.getSourceFile(), lowerer.program)) {
             let receiverType = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
             if (receiverType?.kind !== "classval" && isJsSourceFile(call.getSourceFile())) {
                 const receiver = tryLowerExpression(lowerer, access.expression);
@@ -3919,8 +4500,13 @@ export function lowerStaticMethodCall(lowerer, call, access) {
             // 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) };
+            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)
@@ -3949,31 +4535,42 @@ export function lowerStaticMethodCall(lowerer, call, access) {
     return staticCallOn(lowerer, call, access, info, throughValue);
 }
 /** True when a class-VALUE receiver can only hold `info`'s own class
-   * object at runtime: the receiver provably IS the class
-   * (exactClassOfReceiver — the name, or a const bound to the class
-   * expression / class name), or `info` is a LEAF class, so no strict
-   * descendant exists to flow into the slot (the static-write path's
-   * rule — a rebindable decorated name rides this arm, since replacement
-   * decorators fence any class with subclasses before minting the
-   * rebindable global). Exactly then a #private static access through
-   * the value always carries the declaring class's brand — Node's
-   * TypeError cannot arise. */
+ * object at runtime: the receiver provably IS the class
+ * (exactClassOfReceiver — the name, or a const bound to the class
+ * expression / class name), or `info` is a LEAF class, so no strict
+ * descendant exists to flow into the slot (the static-write path's
+ * rule — a rebindable decorated name rides this arm, since replacement
+ * decorators fence any class with subclasses before minting the
+ * rebindable global). Exactly then a #private static access through
+ * the value always carries the declaring class's brand — Node's
+ * TypeError cannot arise. */
 function classValueIsExactlyOwn(lowerer, recv, info) {
     return exactClassOfReceiver(lowerer, recv) === info || info.subclasses.length === 0;
 }
 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 };
+    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
     // runtime fences, since only the declaring class object carries the
     // brand in JS), and the direct spelling resolves only on the
     // declaring class itself — `D.#s` is Node's TypeError.
-    if (access.name.text.startsWith("#") && throughValue && !classValueIsExactlyOwn(lowerer, access.expression, info)) {
+    if (access.name.text.startsWith("#") &&
+        throughValue &&
+        !classValueIsExactlyOwn(lowerer, access.expression, info)) {
         lowerer.unsupported("SC1090", call, `calling the private static '${access.name.text}' through a class value (JS brands the declaring class object alone — call it through the class's own name)`);
     }
     const found = findStaticOn(lowerer, info, access.name.text);
@@ -3987,14 +4584,14 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         const gfound = findGenericStaticOn(lowerer, info, access.name.text);
         if (!gfound)
             return null;
-        if (throughValue && staticShadowBelow(lowerer, info, access.name.text)) {
+        if (throughValue && staticShadowBelow(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, 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)) {
+    if (throughValue && staticShadowBelow(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);
@@ -4008,7 +4605,12 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         // call through the value (the ctor-assigned-callback pattern).
         if (found.field.type.kind !== "func")
             return null;
-        const callee = { kind: "varRef", localId: found.field.globalId, type: found.field.type, loc };
+        const callee = {
+            kind: "varRef",
+            localId: found.field.globalId,
+            type: found.field.type,
+            loc,
+        };
         const params = found.field.type.params;
         const args = call.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
         for (let i = args.length; i < params.length; i++) {
@@ -4018,17 +4620,32 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
             }
             args.push(absent);
         }
-        return { kind: "callValue", callee, receiver: lowerer.lowerExprExpecting(access.expression, DYN), 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,
+        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" },
-        };
+            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 };
+        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);
@@ -4047,22 +4664,27 @@ function staticMethodForReceiver(lowerer, access, method, receiver, throughValue
     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();
+    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() };
+        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
-   * (values in the slot never leave the subtree). `X.name` is the one
-   * genuinely dynamic member: the class.name libCall reads the runtime
-   * class object's stored name. Null when the receiver isn't a class
-   * value or the member doesn't resolve. */
+ * classval-typed): devirtualized — the member resolves against the
+ * static class's chain, exact when no strict descendant redeclares it
+ * (values in the slot never leave the subtree). `X.name` is the one
+ * genuinely dynamic member: the class.name libCall reads the runtime
+ * class object's stored name. Null when the receiver isn't a class
+ * value or the member doesn't resolve. */
 export function lowerClassValueProperty(lowerer, expr) {
     if (expr.questionDotToken)
         return null;
@@ -4072,9 +4694,16 @@ export function lowerClassValueProperty(lowerer, expr) {
     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 };
+    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.
@@ -4119,7 +4748,7 @@ export function lowerClassValueProperty(lowerer, expr) {
             lowerer.unsupported("SC1090", expr, `reading the private static '${member}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
         }
     }
-    if (staticShadowBelow(lowerer, info, member)) {
+    if (staticShadowBelow(info, member)) {
         lowerer.unsupported("SC1090", expr, `reading the static member '${member}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
     }
     if (found.field !== undefined) {
@@ -4128,18 +4757,21 @@ export function lowerClassValueProperty(lowerer, expr) {
     return staticMethodValue(lowerer, found.declarer, member, found.method, expr, loc);
 }
 /** An abstract method's signature — lambdaSignature minus the body check
-   * (an abstract declaration IS exactly a signature; tsc rejects the
-   * async/generator/generic-with-body combinations before this runs, and
-   * the generic case fences at the caller). */
+ * (an abstract declaration IS exactly a signature; tsc rejects the
+ * async/generator/generic-with-body combinations before this runs, and
+ * the generic case fences at the caller). */
 function abstractMemberSignature(lowerer, member) {
     for (const param of member.parameters) {
         if (!ts.isIdentifier(param.name))
             lowerer.unsupported("SC1031", param);
     }
-    return { shapes: lowerer.paramShapes(member.parameters), ret: lowerer.declaredReturnType(member, member.name) };
+    return {
+        shapes: lowerer.paramShapes(member.parameters),
+        ret: lowerer.declaredReturnType(member, member.name),
+    };
 }
 /** The nearest declaration of `name` at or above `info` — the method a
-   * receiver of that static class runs when nothing below overrides it. */
+ * receiver of that static class runs when nothing below overrides it. */
 export function findMethodOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const sig = c.methods.get(name);
@@ -4150,15 +4782,21 @@ export function findMethodOn(lowerer, info, name) {
 }
 /** True when `sub` is a STRICT descendant of `sup` in the class graph. */
 export function isSubclassOf(lowerer, sub, sup) {
-    for (let c = lowerer.classes.get(sub)?.base ?? null; c; c = c.base) {
-        if (c.def.name === sup)
+    if (sub === sup)
+        return false;
+    for (let c = lowerer.classes.get(sub); c; c = c.base ?? undefined) {
+        if (c.def.name === sup && c.def.name !== sub)
             return true;
+        for (let family = c.genericInstance?.family; family; family = family.base ?? undefined) {
+            if (family.def.name === sup)
+                return true;
+        }
     }
     return false;
 }
 /** In an extends-hierarchy (as base or derived): the class carries a
-   * vtable and participates in dynamic instanceof; standalone classes keep
-   * their exact pre-inheritance layout and behavior. */
+ * vtable and participates in dynamic instanceof; standalone classes keep
+ * their exact pre-inheritance layout and behavior. */
 export function inHierarchy(lowerer, info) {
     // The runtime emitter class is ALWAYS a hierarchy member: ScrEmitter
     // carries its vtable word whether or not the program subclasses it
@@ -4166,10 +4804,10 @@ export function inHierarchy(lowerer, info) {
     return info.base !== null || info.subclasses.length > 0 || info.builtinEmitter === true;
 }
 /** True when some STRICT descendant of `info` declares `name` with a BODY
-   * — the whole-program devirtualization test: a call through this static
-   * class can reach a distinct implementation, so it must dispatch
-   * dynamically. Abstract re-declarations don't count (they carry no
-   * implementation; the concrete ones below them do, via the recursion). */
+ * — the whole-program devirtualization test: a call through this static
+ * class can reach a distinct implementation, so it must dispatch
+ * dynamically. Abstract re-declarations don't count (they carry no
+ * implementation; the concrete ones below them do, via the recursion). */
 export function overrideBelow(lowerer, info, name) {
     return info.subclasses.some((s) => {
         const m = s.methods.get(name);
@@ -4177,7 +4815,7 @@ export function overrideBelow(lowerer, info, name) {
     });
 }
 /** The nearest GENERIC-method declaration of `name` at/above `info` —
-   * findMethodOn's twin over the genericMethods tables. */
+ * findMethodOn's twin over the genericMethods tables. */
 export function findGenericMethodOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const gm = c.genericMethods?.get(name);
@@ -4187,11 +4825,11 @@ export function findGenericMethodOn(lowerer, info, name) {
     return null;
 }
 /** True when some STRICT descendant of `info` re-declares the generic
-   * 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. */
-export function genericOverrideBelow(lowerer, info, name) {
-    return info.subclasses.some((s) => s.genericMethods?.has(name) === true || genericOverrideBelow(lowerer, s, 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. */
+export function genericOverrideBelow(info, name) {
+    return info.subclasses.some((s) => s.genericMethods?.has(name) === true || genericOverrideBelow(s, name));
 }
 /** Discover inherited data writes before any base storage ABI is chosen.
  * The checker does not widen a base field for assignments in JS subclasses. */
@@ -4200,7 +4838,8 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
         if (!isJsSourceFile(file))
             continue;
         ts.walkPreorder(file, (node) => {
-            if ((!ts.isClassDeclaration(node) && !ts.isClassExpression(node)) || !node.heritageClauses?.length)
+            if ((!ts.isClassDeclaration(node) && !ts.isClassExpression(node)) ||
+                !node.heritageClauses?.length)
                 return;
             const writes = new Map();
             const addWrite = (name, expression) => {
@@ -4211,14 +4850,17 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
                     writes.set(name, [expression]);
             };
             const scan = (part) => {
-                if (ts.isClassDeclaration(part) || ts.isClassExpression(part) ||
-                    ts.isFunctionLike(part) && !ts.isArrowFunction(part))
+                if (ts.isClassDeclaration(part) ||
+                    ts.isClassExpression(part) ||
+                    (ts.isFunctionLike(part) && !ts.isArrowFunction(part)))
                     return;
                 if (ts.isBinaryExpression(part) && part.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
                     const left = part.left;
-                    if (ts.isPropertyAccessExpression(left) && left.expression.kind === ts.SyntaxKind.ThisKeyword)
+                    if (ts.isPropertyAccessExpression(left) &&
+                        left.expression.kind === ts.SyntaxKind.ThisKeyword)
                         addWrite(left.name.text, part.right);
-                    else if (ts.isElementAccessExpression(left) && left.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                    else if (ts.isElementAccessExpression(left) &&
+                        left.expression.kind === ts.SyntaxKind.ThisKeyword) {
                         const name = lowerer.foldedStringKeyOf(left.argumentExpression);
                         if (name !== null)
                             addWrite(name, part.right);
@@ -4230,12 +4872,16 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
                 if (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))
                     continue;
                 if (ts.isPropertyDeclaration(member) && member.initializer) {
-                    const name = ts.isPrivateIdentifier(member.name) ? null : classMemberNameOf(lowerer, member.name);
+                    const name = ts.isPrivateIdentifier(member.name)
+                        ? null
+                        : classMemberNameOf(lowerer, member.name);
                     if (name !== null)
                         addWrite(name, member.initializer);
                     scan(member.initializer);
                 }
-                if (ts.isConstructorDeclaration(member) || ts.isMethodDeclaration(member) || ts.isAccessor(member)) {
+                if (ts.isConstructorDeclaration(member) ||
+                    ts.isMethodDeclaration(member) ||
+                    ts.isAccessor(member)) {
                     if (member.body)
                         scan(member.body);
                 }
@@ -4259,11 +4905,13 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
                             let owner = declaration.parent;
                             while (owner && !ts.isClassDeclaration(owner) && !ts.isClassExpression(owner))
                                 owner = owner.parent;
-                            if (!owner || (!ts.isClassDeclaration(owner) && !ts.isClassExpression(owner)) || !isJsSourceFile(owner.getSourceFile()))
+                            if (!owner ||
+                                (!ts.isClassDeclaration(owner) && !ts.isClassExpression(owner)) ||
+                                !isJsSourceFile(owner.getSourceFile()))
                                 continue;
                             let fields = lowerer.inheritedJsFieldWrites.get(owner);
                             if (!fields)
-                                lowerer.inheritedJsFieldWrites.set(owner, fields = new Map());
+                                lowerer.inheritedJsFieldWrites.set(owner, (fields = new Map()));
                             const existing = fields.get(name);
                             if (existing)
                                 existing.push(...expressions);
@@ -4292,24 +4940,35 @@ export function collectVirtualJsMethods(lowerer, 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;
+            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)) {
+            const assigned = ts.isBinaryExpression(node.parent) &&
+                node.parent.left === node &&
+                node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
+            const symbol = !assigned
+                ? undefined
+                : ts.isPropertyAccessExpression(node)
+                    ? lowerer.checker.getSymbolAtLocation(node.name)
+                    : lowerer.checker.getPropertyOfType(lowerer.typeOf(node.expression), name);
+            if (prototype ||
+                (symbol && lowerer.checker.declarationsOf(symbol).some(ts.isMethodDeclaration))) {
                 lowerer.prototypeMethodAccesses.set(name, node);
             }
         });
     const visit = (node) => {
         if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
-            const accessors = node.members.filter((member) => (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) && ts.isIdentifier(member.name) &&
+            const accessors = node.members.filter((member) => (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) &&
+                ts.isIdentifier(member.name) &&
                 !member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
-            if (node.heritageClauses?.length && accessors.length && isJsSourceFile(node.getSourceFile())) {
+            if (node.heritageClauses?.length &&
+                accessors.length &&
+                isJsSourceFile(node.getSourceFile())) {
                 const symbol = lowerer.typeOf(node).getSymbol();
                 const instance = symbol ? lowerer.checker.getDeclaredTypeOfSymbol(symbol) : null;
                 const seen = new Set();
@@ -4324,12 +4983,15 @@ export function collectVirtualJsMethods(lowerer, files) {
                                 continue;
                             const property = lowerer.checker.getPropertyOfType(base, member.name.text);
                             for (const declaration of property ? lowerer.checker.declarationsOf(property) : []) {
-                                if ((ts.isGetAccessorDeclaration(declaration) || ts.isSetAccessorDeclaration(declaration)) && isJsSourceFile(declaration.getSourceFile())) {
+                                if ((ts.isGetAccessorDeclaration(declaration) ||
+                                    ts.isSetAccessorDeclaration(declaration)) &&
+                                    isJsSourceFile(declaration.getSourceFile())) {
                                     lowerer.checkedVirtualJsAccessors.add(declaration);
                                     lowerer.checkedVirtualJsAccessors.add(member);
                                     for (const twin of node.members)
                                         if ((ts.isGetAccessorDeclaration(twin) || ts.isSetAccessorDeclaration(twin)) &&
-                                            ts.isIdentifier(twin.name) && twin.name.text === member.name.text)
+                                            ts.isIdentifier(twin.name) &&
+                                            twin.name.text === member.name.text)
                                             lowerer.checkedVirtualJsAccessors.add(twin);
                                 }
                             }
@@ -4340,7 +5002,8 @@ export function collectVirtualJsMethods(lowerer, files) {
                 if (instance)
                     markAccessors(instance);
             }
-            const members = node.members.filter((member) => ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&
+            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();
@@ -4357,14 +5020,18 @@ export function collectVirtualJsMethods(lowerer, files) {
                                 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())) {
+                                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) &&
+                                    if (isJsSourceFile(member.getSourceFile()) &&
+                                        !member.typeParameters &&
+                                        !member.asteriskToken &&
+                                        !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
                                         !bodyReadsArguments(member) &&
                                         member.parameters.every((p) => !p.dotDotDotToken)) {
                                         lowerer.virtualJsMethodArity.set(declaration, Math.max(lowerer.virtualJsMethodArity.get(declaration) ?? 0, member.parameters.length));
-                                        const checked = !declaration.typeParameters && !declaration.asteriskToken &&
+                                        const checked = !declaration.typeParameters &&
+                                            !declaration.asteriskToken &&
                                             !declaration.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
                                             !bodyReadsArguments(declaration) &&
                                             [...member.parameters, ...declaration.parameters].every((p) => !p.dotDotDotToken);
@@ -4401,7 +5068,8 @@ export function collectVirtualJsMethods(lowerer, files) {
     while (changed) {
         changed = false;
         for (const [base, derived] of families) {
-            if (!lowerer.checkedVirtualJsValueReturns.has(base) && !lowerer.checkedVirtualJsValueReturns.has(derived))
+            if (!lowerer.checkedVirtualJsValueReturns.has(base) &&
+                !lowerer.checkedVirtualJsValueReturns.has(derived))
                 continue;
             for (const member of [base, derived])
                 if (!lowerer.checkedVirtualJsValueReturns.has(member)) {
@@ -4412,11 +5080,11 @@ export function collectVirtualJsMethods(lowerer, files) {
     }
 }
 /** 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).
-   * The class is read off the mapped INITIALIZER type — a `const b: Base =
-   * new D()` receiver is exactly D, not its annotation. Distinct from
-   * exactClassOfReceiver, which answers for CLASS-VALUE receivers. */
+ * `new C(...)` expression directly, or a const binding initialized with
+ * one (the binding can never be reassigned to a subclass instance).
+ * The class is read off the mapped INITIALIZER type — a `const b: Base =
+ * new D()` receiver is exactly D, not its annotation. Distinct from
+ * exactClassOfReceiver, which answers for CLASS-VALUE receivers. */
 export function exactInstanceClassOf(lowerer, expr) {
     let e = expr;
     while (ts.isParenthesizedExpression(e))
@@ -4434,7 +5102,9 @@ export function exactInstanceClassOf(lowerer, expr) {
         return null;
     const symbol = lowerer.resolveValueSymbol(e);
     const decl = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
-    if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined ||
+    if (!decl ||
+        !ts.isVariableDeclaration(decl) ||
+        decl.initializer === undefined ||
         !ts.isVariableDeclarationList(decl.parent) ||
         (decl.parent.flags & ts.NodeFlags.Const) === 0) {
         return null;
@@ -4445,19 +5115,19 @@ export function exactInstanceClassOf(lowerer, expr) {
     return classOfNew(init);
 }
 /** `const r: Repo = new MemRepo()` where EVERY member of the annotation's
-   * checker type is a generic-callable method (`interface Repo { get<T>(id:
-   * string): T }`): the record shape maps EMPTY — generic members are
-   * excluded (no closure slot can hold a generic function) — so the
-   * copy-reshape width coercion would DROP the exact class the method
-   * calls monomorphize against, and in JS the binding IS the instance (no
-   * copy exists). The binding keeps the initializer's class
-   * representation instead: generic-method calls resolve like class-typed
-   * receivers (exactInstanceClassOf reads the same const+new discipline),
-   * and uses that want the empty record width-coerce at the use site.
-   * Const + direct `new` only — a reassignable binding or a produced
-   * value keeps today's record story and its fences. */
+ * checker type is a generic-callable method (`interface Repo { get<T>(id:
+ * string): T }`): the record shape maps EMPTY — generic members are
+ * excluded (no closure slot can hold a generic function) — so the
+ * copy-reshape width coercion would DROP the exact class the method
+ * calls monomorphize against, and in JS the binding IS the instance (no
+ * copy exists). The binding keeps the initializer's class
+ * representation instead: generic-method calls resolve like class-typed
+ * receivers (exactInstanceClassOf reads the same const+new discipline),
+ * and uses that want the empty record width-coerce at the use site.
+ * Const + direct `new` only — a reassignable binding or a produced
+ * value keeps today's record story and its fences. */
 export function genericIfaceBindingKeepsClass(lowerer, decl, declaredType) {
-    if (declaredType.kind !== "record")
+    if (declaredType.kind !== "record" && declaredType.kind !== "dyn")
         return false;
     if (!ts.isIdentifier(decl.name) || decl.initializer === undefined || decl.type === undefined)
         return false;
@@ -4468,27 +5138,30 @@ export function genericIfaceBindingKeepsClass(lowerer, decl, declaredType) {
         init = init.expression;
     if (!ts.isNewExpression(init))
         return false;
-    const shape = lowerer.shapes.get(declaredType.shapeId);
-    if (!shape || shape.fields.length > 0 || shape.indexValue !== undefined || shape.tuple === true)
-        return false;
     const annT = lowerer.typeOf(decl.name);
     const props = lowerer.checker.getPropertiesOfType(annT);
     if (props.length === 0)
         return false;
+    if (declaredType.kind === "dyn")
+        return (lowerer.classImplementedProtocol(annT) &&
+            props.some((property) => isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(property), lowerer.checker)));
+    const shape = lowerer.shapes.get(declaredType.shapeId);
+    if (!shape || shape.fields.length > 0 || shape.indexValue !== undefined || shape.tuple === true)
+        return false;
     return props.every((p) => isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(p), lowerer.checker));
 }
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
-   * checker's resolved signature (type arguments substituted, inferred or
-   * explicit) keys one instantiation of the nearest declarer's body, and
-   * the call is a direct `call` of `%C.m%n` over the (up/down)cast
-   * receiver. No per-instantiation vtable slots exist, so a receiver whose
-   * runtime class could OVERRIDE the method (genericOverrideBelow) must be
-   * statically exact (exactInstanceClassOf) — the override set then
-   * resolves at compile time — or fences by name. */
+ * checker's resolved signature (type arguments substituted, inferred or
+ * explicit) keys one instantiation of the nearest declarer's body, and
+ * the call is a direct `call` of `%C.m%n` over the (up/down)cast
+ * receiver. No per-instantiation vtable slots exist, so a receiver whose
+ * runtime class could OVERRIDE the method (genericOverrideBelow) must be
+ * statically exact (exactInstanceClassOf) — the override set then
+ * resolves at compile time — or fences by name. */
 export function lowerClassGenericMethodCall(lowerer, call, access, recvInfo, found, recvIr) {
     const name = access.name.text;
     let { declarer, info } = found;
-    if (genericOverrideBelow(lowerer, recvInfo, name)) {
+    if (genericOverrideBelow(recvInfo, name)) {
         const exact = exactInstanceClassOf(lowerer, access.expression);
         const refound = exact ? findGenericMethodOn(lowerer, exact, name) : null;
         if (!refound) {
@@ -4509,14 +5182,26 @@ export function lowerClassGenericMethodCall(lowerer, call, access, recvInfo, fou
     // path; the EXACT path can land below it (a base-typed const provably
     // holding the subclass) — that direction is the checker-grade downcast
     // (the exactness proof is static, stronger than an instanceof guard).
-    const thisArg = receiver.type.kind === "object" && isSubclassOf(lowerer, declarer.def.name, receiver.type.className)
-        ? { kind: "downcast", value: receiver, type: { kind: "object", className: declarer.def.name }, loc }
+    const thisArg = receiver.type.kind === "object" &&
+        isSubclassOf(lowerer, declarer.def.name, receiver.type.className)
+        ? {
+            kind: "downcast",
+            value: receiver,
+            type: { kind: "object", className: declarer.def.name },
+            loc,
+        }
         : upcastTo(lowerer, receiver, declarer.def.name);
     const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
-    return { kind: "call", callee: instance.name, args: [thisArg, ...args], type: instance.returnType, loc };
+    return {
+        kind: "call",
+        callee: instance.name,
+        args: [thisArg, ...args],
+        type: instance.returnType,
+        loc,
+    };
 }
 /** Wraps a derived-class expression in an upcast when the target base
-   * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
+ * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
 export function upcastTo(lowerer, expr, className) {
     if (expr.type.kind === "object" && expr.type.className !== className) {
         return { kind: "upcast", value: expr, type: { kind: "object", className }, loc: expr.loc };
@@ -4524,12 +5209,12 @@ export function upcastTo(lowerer, expr, className) {
     return expr;
 }
 /** Constructor and methods become module functions `%C.name` whose first
-   * param is `this`. Field initializers run in declaration order at the top
-   * of a base class's constructor; a derived class's run right after its
-   * super() call returns (tsc/JS initialization order). Reachability gates
-   * each member independently: an unreached method body never lowers and
-   * never emits (pinned by the corpus), while every override a reachable
-   * virtualCall can dispatch to was marked by the discovery pass. */
+ * param is `this`. Field initializers run in declaration order at the top
+ * of a base class's constructor; a derived class's run right after its
+ * super() call returns (tsc/JS initialization order). Reachability gates
+ * each member independently: an unreached method body never lowers and
+ * never emits (pinned by the corpus), while every override a reachable
+ * virtualCall can dispatch to was marked by the discovery pass. */
 /** True when a MIXIN class's constructor is the pure forwarding shape:
  * exactly one rest parameter, `super(...args)` as the first statement,
  * and no other reference to the parameter — the one rest-constructor
@@ -4563,7 +5248,9 @@ function mixinForwardingCtor(lowerer, ctor) {
     ts.walkPreorder(ctor.body, (n) => {
         if (n === spreadIdent)
             return undefined;
-        if (ts.isIdentifier(n) && n.text === paramName.text && lowerer.checker.getSymbolAtLocation(n) === paramSym) {
+        if (ts.isIdentifier(n) &&
+            n.text === paramName.text &&
+            lowerer.checker.getSymbolAtLocation(n) === paramSym) {
             extraRef = true;
             return "stop";
         }
@@ -4585,7 +5272,9 @@ export function lowerClassMembers(lowerer, info) {
     // 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 || info.localClass !== 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.
@@ -4603,10 +5292,19 @@ export function lowerClassMembers(lowerer, info) {
             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 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 })),
+                    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);
@@ -4641,9 +5339,9 @@ export function lowerClassMembers(lowerer, info) {
     return out;
 }
 /** The constructor function `%C.constructor`. Synthesized when absent: a
-   * base class runs just its field initializers; a derived class inherits
-   * the base's signature — forward every param to super(), then run own
-   * field initializers. */
+ * base class runs just its field initializers; a derived class inherits
+ * 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)
@@ -4656,11 +5354,16 @@ function classCaptureParams(info, context) {
     const environment = info.localClass.context;
     if (!environment)
         throw new InternalCompilerError("local class lowered outside its lexical environment");
-    return { classCaptures: (context.captures ?? []).map((capture, index) => {
+    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]) };
-        }) };
+            return {
+                ...capture,
+                slot: environment.captures.findIndex((entry) => entry.localId === context.captureSources[index]),
+            };
+        }),
+    };
 }
 function lowerClassCtorInner(lowerer, info) {
     const className = info.def.name;
@@ -4683,7 +5386,12 @@ function lowerClassCtorInner(lowerer, info) {
             // unchanged, and the remaining statements lower normally.
             const loc = locOf(info.ctor);
             const forward = info.ctorParams.map((shape, i) => {
-                const local = { id: `arg${i}.0`, name: `arg${i}`, type: shape.type, mutable: false };
+                const local = {
+                    id: `arg${i}.0`,
+                    name: `arg${i}`,
+                    type: shape.type,
+                    mutable: false,
+                };
                 lowerer.ctx.locals.push(local);
                 params.push({ localId: local.id, name: local.name, type: shape.type });
                 return { kind: "varRef", localId: local.id, type: shape.type, loc };
@@ -4724,7 +5432,12 @@ function lowerClassCtorInner(lowerer, info) {
                 // apply in the base constructor's own prologue, never twice).
                 const loc = locOf(info.decl);
                 const superArgs = info.ctorParams.map((shape, i) => {
-                    const local = { id: `arg${i}.0`, name: `arg${i}`, type: shape.type, mutable: false };
+                    const local = {
+                        id: `arg${i}.0`,
+                        name: `arg${i}`,
+                        type: shape.type,
+                        mutable: false,
+                    };
                     lowerer.ctx.locals.push(local);
                     params.push({ localId: local.id, name: local.name, type: shape.type });
                     return { kind: "varRef", localId: local.id, type: shape.type, loc };
@@ -4758,14 +5471,14 @@ function lowerClassCtorInner(lowerer, info) {
     }
 }
 /** The lowered method-map name of a class member: identifier text, a
-   * COMPUTED name that folds to one compile-time string
-   * (foldedStringKeyOf — the object-literal computed-key machinery
-   * applied to method positions; tsc late-bound the member under exactly
-   * that name), or a reserved `sym:*` slot for the well-known symbols the
-   * compiler consumes as language protocols (iterator and explicit
-   * resource management). These names are unspellable as user identifiers,
-   * like the accessor `get:x` convention. Null for genuinely
-   * runtime-keyed names — the computed-member fences stay. */
+ * COMPUTED name that folds to one compile-time string
+ * (foldedStringKeyOf — the object-literal computed-key machinery
+ * applied to method positions; tsc late-bound the member under exactly
+ * that name), or a reserved `sym:*` slot for the well-known symbols the
+ * compiler consumes as language protocols (iterator and explicit
+ * resource management). These names are unspellable as user identifiers,
+ * like the accessor `get:x` convention. Null for genuinely
+ * runtime-keyed names — the computed-member fences stay. */
 export function classMemberNameOf(lowerer, name) {
     if (ts.isIdentifier(name))
         return name.text;
@@ -4791,7 +5504,8 @@ export function classMemberNameOf(lowerer, name) {
             return `sym:${member}`;
         }
     }
-    return classSymbolKeyOf(lowerer, name.expression)?.fieldName ?? lowerer.foldedStringKeyOf(name.expression);
+    return (classSymbolKeyOf(lowerer, name.expression)?.fieldName ??
+        lowerer.foldedStringKeyOf(name.expression));
 }
 export function classIteratorOf(lowerer, t) {
     if (t.kind !== "object")
@@ -4825,10 +5539,16 @@ export function classIteratorOf(lowerer, t) {
     const done = shape.fields.find((f) => f.name === "done");
     if (done && done.type.kind !== "bool")
         return null;
-    return { className: t.className, iterT, resultT, valueT: value.type, hasDone: done !== undefined };
+    return {
+        className: t.className,
+        iterT,
+        resultT,
+        valueT: value.type,
+        hasDone: done !== undefined,
+    };
 }
 /** The `it.next()` step of a class iterator as an ordinary (possibly
-   * virtual) method call. */
+ * virtual) method call. */
 export function classIteratorNextCall(lowerer, cit, itRef, loc) {
     return accessorCall(lowerer, cit.iterT.className, "next", itRef, [], cit.resultT, loc);
 }
@@ -4837,14 +5557,14 @@ export function classIteratorOpenCall(lowerer, cit, recv, loc) {
     return accessorCall(lowerer, cit.className, "sym:iterator", recv, [], cit.iterT, loc);
 }
 /** `[...new C]` / `f(...new C)` over a CLASS ITERABLE: the eager drain —
-   * an interned `%iter.drain.<n>(recv)` lifted function running the
-   * whole protocol into a fresh element array (a doneless iterator loops
-   * forever, exactly Node's spread of an infinite iterator). `elemT`
-   * (default: the iterator's own value type) is the DESTINATION element —
-   * a spread into a union-element literal (`[...numbers, ...symbols]` as
-   * `(number | symbol)[]`) pushes each value wrapped into its arm. Null
-   * when the value isn't a recognized class iterable or the element
-   * doesn't coerce — spread fences stay. */
+ * an interned `%iter.drain.<n>(recv)` lifted function running the
+ * whole protocol into a fresh element array (a doneless iterator loops
+ * forever, exactly Node's spread of an infinite iterator). `elemT`
+ * (default: the iterator's own value type) is the DESTINATION element —
+ * a spread into a union-element literal (`[...numbers, ...symbols]` as
+ * `(number | symbol)[]`) pushes each value wrapped into its arm. Null
+ * when the value isn't a recognized class iterable or the element
+ * doesn't coerce — spread fences stay. */
 export function classIteratorDrainCall(lowerer, src, loc, elemT) {
     const cit = classIteratorOf(lowerer, src.type);
     if (!cit)
@@ -4867,14 +5587,33 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
         const itRef = { kind: "varRef", localId: "it.0", type: cit.iterT, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: outT, loc };
         const resRef = { kind: "varRef", localId: "res.0", type: cit.resultT, loc };
-        const valueRead = { kind: "recordGet", obj: resRef, shapeId: cit.resultT.shapeId, field: "value", type: cit.valueT, loc };
+        const valueRead = {
+            kind: "recordGet",
+            obj: resRef,
+            shapeId: cit.resultT.shapeId,
+            field: "value",
+            type: cit.valueT,
+            loc,
+        };
         const loop = [
-            { kind: "varDecl", localId: "res.0", init: classIteratorNextCall(lowerer, cit, itRef, loc), loc },
+            {
+                kind: "varDecl",
+                localId: "res.0",
+                init: classIteratorNextCall(lowerer, cit, itRef, loc),
+                loc,
+            },
             ...(cit.hasDone
                 ? [
                     {
                         kind: "if",
-                        cond: { kind: "recordGet", obj: resRef, shapeId: cit.resultT.shapeId, field: "done", type: BOOL, loc },
+                        cond: {
+                            kind: "recordGet",
+                            obj: resRef,
+                            shapeId: cit.resultT.shapeId,
+                            field: "done",
+                            type: BOOL,
+                            loc,
+                        },
                         then: [{ kind: "return", value: outRef, loc }],
                         else_: null,
                         loc,
@@ -4905,8 +5644,18 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
                 { id: "res.0", name: "res", type: cit.resultT, mutable: true },
             ],
             body: [
-                { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: outT, loc }, loc },
-                { kind: "varDecl", localId: "it.0", init: classIteratorOpenCall(lowerer, cit, recvRef, loc), loc },
+                {
+                    kind: "varDecl",
+                    localId: "out.0",
+                    init: { kind: "arrayLit", elems: [], type: outT, loc },
+                    loc,
+                },
+                {
+                    kind: "varDecl",
+                    localId: "it.0",
+                    init: classIteratorOpenCall(lowerer, cit, recvRef, loc),
+                    loc,
+                },
                 {
                     kind: "while",
                     cond: { kind: "boolLit", value: true, type: BOOL, loc },
@@ -4917,7 +5666,12 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
                 // all-paths-return rule (the retag-helper convention).
                 {
                     kind: "throw",
-                    value: { kind: "strLit", value: "scriptc: internal error: iterator drain fell through", type: STRING, loc },
+                    value: {
+                        kind: "strLit",
+                        value: "scriptc: internal error: iterator drain fell through",
+                        type: STRING,
+                        loc,
+                    },
                     loc,
                 },
             ],
@@ -4927,8 +5681,8 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
     return { kind: "call", callee: name, args: [src], type: outT, loc };
 }
 /** The tail of a class iterable's protocol from an already-open ITERATOR
-   * object (`var [a, ...rest] = new C` — the rest element drains whatever
-   * next() still yields): the drain loop keyed by the iterator class. */
+ * object (`var [a, ...rest] = new C` — the rest element drains whatever
+ * next() still yields): the drain loop keyed by the iterator class. */
 export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
     const outT = arrayOf(cit.valueT);
     const key = `it:${cit.iterT.className}`;
@@ -4940,12 +5694,24 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
         const outRef = { kind: "varRef", localId: "out.0", type: outT, loc };
         const resRef = { kind: "varRef", localId: "res.0", type: cit.resultT, loc };
         const loop = [
-            { kind: "varDecl", localId: "res.0", init: classIteratorNextCall(lowerer, cit, itRef, loc), loc },
+            {
+                kind: "varDecl",
+                localId: "res.0",
+                init: classIteratorNextCall(lowerer, cit, itRef, loc),
+                loc,
+            },
             ...(cit.hasDone
                 ? [
                     {
                         kind: "if",
-                        cond: { kind: "recordGet", obj: resRef, shapeId: cit.resultT.shapeId, field: "done", type: BOOL, loc },
+                        cond: {
+                            kind: "recordGet",
+                            obj: resRef,
+                            shapeId: cit.resultT.shapeId,
+                            field: "done",
+                            type: BOOL,
+                            loc,
+                        },
                         then: [{ kind: "return", value: outRef, loc }],
                         else_: null,
                         loc,
@@ -4958,7 +5724,16 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
                     kind: "arrIntrinsic",
                     method: "push",
                     receiver: outRef,
-                    args: [{ kind: "recordGet", obj: resRef, shapeId: cit.resultT.shapeId, field: "value", type: cit.valueT, loc }],
+                    args: [
+                        {
+                            kind: "recordGet",
+                            obj: resRef,
+                            shapeId: cit.resultT.shapeId,
+                            field: "value",
+                            type: cit.valueT,
+                            loc,
+                        },
+                    ],
                     type: F64,
                     loc,
                 },
@@ -4975,11 +5750,21 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
                 { id: "res.0", name: "res", type: cit.resultT, mutable: true },
             ],
             body: [
-                { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: outT, loc }, loc },
+                {
+                    kind: "varDecl",
+                    localId: "out.0",
+                    init: { kind: "arrayLit", elems: [], type: outT, loc },
+                    loc,
+                },
                 { kind: "while", cond: { kind: "boolLit", value: true, type: BOOL, loc }, body: loop, loc },
                 {
                     kind: "throw",
-                    value: { kind: "strLit", value: "scriptc: internal error: iterator drain fell through", type: STRING, loc },
+                    value: {
+                        kind: "strLit",
+                        value: "scriptc: internal error: iterator drain fell through",
+                        type: STRING,
+                        loc,
+                    },
                     loc,
                 },
             ],
@@ -4989,12 +5774,14 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
     return { kind: "call", callee: name, args: [itVal], type: outT, loc };
 }
 /** One method or accessor body as its module function `%C.name`
-   * (accessors are methods with property syntax: "get:x"/"set:x" entries —
-   * see collectClassShape). */
+ * (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}`;
+        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));
@@ -5088,12 +5875,12 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
     }
 }
 /** One static method body as its module function `%C.static:m` — an
-   * ordinary function with NO `this` param. `this` and `super` inside
-   * name the RECEIVER class in JS (dynamic — `F.who()` sees F even when
-   * who() is declared on E), which has no static story here: both are
-   * named fences, with arrow functions transparent (they inherit the
-   * method's `this`) and this-binding function forms opaque — the static-
-   * block rule verbatim. */
+ * ordinary function with NO `this` param. `this` and `super` inside
+ * name the RECEIVER class in JS (dynamic — `F.who()` sees F even when
+ * who() is declared on E), which has no static story here: both are
+ * named fences, with arrow functions transparent (they inherit the
+ * method's `this`) and this-binding function forms opaque — the static-
+ * block rule verbatim. */
 export function lowerStaticMethod(lowerer, info, name) {
     const entry = info.staticMethods?.get(name);
     if (!entry?.member.body)
@@ -5109,7 +5896,9 @@ export function lowerStaticMethod(lowerer, info, 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;
+        : isAsync && entry.ret.kind === "promise"
+            ? entry.ret.inner
+            : entry.ret;
     const fnCtx = newFnCtx(false, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
     if (genCh !== null)
@@ -5153,10 +5942,10 @@ export function lowerStaticMethod(lowerer, info, name) {
     }
 }
 /** A synthesized throwing setter: a getter-only override shadows the
-   * inherited pair (JS), so a base-typed write dispatches HERE and must
-   * throw exactly like Node's TypeError — a real instance (a typed catch's
-   * `e instanceof TypeError` matches), catchable, exit 1 uncaught (message
-   * text is compiler-worded; stdout and exit code are the contract). */
+ * inherited pair (JS), so a base-typed write dispatches HERE and must
+ * throw exactly like Node's TypeError — a real instance (a typed catch's
+ * `e instanceof TypeError` matches), catchable, exit 1 uncaught (message
+ * text is compiler-worded; stdout and exit code are the contract). */
 export function throwingSetterFn(lowerer, info, prop) {
     const className = info.def.name;
     const thisType = { kind: "object", className };
@@ -5195,27 +5984,38 @@ export function throwingSetterFn(lowerer, info, prop) {
     };
 }
 /** The base a constructor chain actually CALLS into: generic FAMILIES are
-   * never constructed (no `%<family>.constructor` exists), so an
-   * instantiation's construction-relevant base is the family's own base —
-   * null when the generic class extends nothing, exactly the source's
-   * story (tsc forbids super() there). Ordinary classes answer their base
-   * unchanged. */
+ * never constructed (no `%<family>.constructor` exists), so an
+ * instantiation's construction-relevant base is the family's own base —
+ * null when the generic class extends nothing, exactly the source's
+ * story (tsc forbids super() there). Ordinary classes answer their base
+ * unchanged. */
 function superBaseOf(info) {
     const b = info.base;
     return b?.generic ? b.base : b;
 }
 /** The class's OWN field initializers as fieldSet statements (declaration
-   * order) — a base constructor's prologue, a derived constructor's
-   * super()-return continuation. */
+ * order) — a base constructor's prologue, a derived constructor's
+ * super()-return continuation. */
 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 });
+            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) {
@@ -5251,7 +6051,9 @@ export function fieldInitStmts(lowerer, info, thisLocal) {
             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" });
+                const fence = lowerer.deferToRuntimeFence(diagsBefore, f.initializer, {
+                    kind: "statement",
+                });
                 if (fence)
                     out.push(fence);
             }
@@ -5260,14 +6062,14 @@ export function fieldInitStmts(lowerer, info, thisLocal) {
     return out;
 }
 /** PARAMETER-PROPERTY assignments (`this.x = x`, synthesized): run AFTER
-   * the field initializers — Node's transform defines the fields at the
-   * top of the class body (undefined until assigned) and injects the
-   * assignments at the start of the constructor body, i.e. after super()
-   * and after the (native) field initializers ran (probed: a field
-   * initializer reading `this.x` sees undefined; the body sees the value).
-   * Each assignment reads the parameter's BODY local (defaults already
-   * applied by the declareParams prologue), whose type the collection made
-   * the field's type — slot-exact by construction. */
+ * the field initializers — Node's transform defines the fields at the
+ * top of the class body (undefined until assigned) and injects the
+ * assignments at the start of the constructor body, i.e. after super()
+ * and after the (native) field initializers ran (probed: a field
+ * initializer reading `this.x` sees undefined; the body sees the value).
+ * Each assignment reads the parameter's BODY local (defaults already
+ * applied by the declareParams prologue), whose type the collection made
+ * the field's type — slot-exact by construction. */
 function paramPropInitStmts(lowerer, info, thisLocal) {
     const out = [];
     const thisType = { kind: "object", className: info.def.name };
@@ -5291,8 +6093,8 @@ function paramPropInitStmts(lowerer, info, thisLocal) {
     return 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. */
+ * whichever control-flow path executes. Repeated calls are explicitly
+ * refused until native layouts can allocate a second receiver. */
 export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
     let superSeen = false;
     const initialized = lowerer.declareHiddenLocal("%superInitialized", BOOL);
@@ -5306,11 +6108,30 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
             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 }];
+        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 };
+            const pack = {
+                kind: "dynArrLit",
+                elems: superCall.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                type: DYN,
+                loc,
+            };
             statements.push(lowerer.superCallStmt(info, thisLocal, [pack], loc));
         }
         else {
@@ -5321,19 +6142,33 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
                 statements.push(...lowerStreamSuperCall(lowerer, info, base, superCall.arguments, thisLocal, loc, superCall));
             }
             else {
-                const surplusSpread = forward === undefined && !base.builtinError && !base.builtinEmitter &&
-                    base.ctorParams.length === 0 && superCall.arguments.some(ts.isSpreadElement);
+                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 &&
+                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);
+                    !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);
@@ -5341,13 +6176,22 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
                         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({
+                            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 });
+        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));
@@ -5356,16 +6200,52 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
             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 };
+        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) });
+        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];
+        return [
+            {
+                kind: "varDecl",
+                localId: initialized.id,
+                init: { kind: "boolLit", value: false, type: BOOL, loc: locOf(info.ctor) },
+                loc: locOf(info.ctor),
+            },
+            ...result,
+        ];
     }
     finally {
         if (previous)
@@ -5379,8 +6259,8 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
     }
 }
 /** `super(args)` → direct call of the base constructor with the SAME
-   * `this` (upcast; retained by the varRef read — the callee owns and
-   * releases its param per the universal convention). */
+ * `this` (upcast; retained by the varRef read — the callee owns and
+ * releases its param per the universal convention). */
 export function superCallStmt(lowerer, info, thisLocal, args, loc) {
     const base = superBaseOf(info);
     const thisRef = {
@@ -5391,12 +6271,41 @@ export function superCallStmt(lowerer, info, thisLocal, args, 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,
+            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
@@ -5453,8 +6362,8 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
     };
 }
 /** `super.method(args)`: the base chain's implementation, called
-   * DIRECTLY over this method's own `this` (upcast to the declarer) —
-   * super dispatch is static in JS too, never through the dynamic class. */
+ * DIRECTLY over this method's own `this` (upcast to the declarer) —
+ * super dispatch is static in JS too, never through the dynamic class. */
 export function lowerSuperMethodCall(lowerer, call, access) {
     const cls = lowerer.currentClass;
     if (!cls?.base) {
@@ -5516,15 +6425,33 @@ export function lowerSuperMethodCall(lowerer, call, access) {
     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 };
+            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 };
+        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);
@@ -5537,7 +6464,7 @@ export function lowerSuperMethodCall(lowerer, call, access) {
     };
 }
 /** The `this` reference for super accessor reads/writes, with the shared
-   * validity checks (derived-class body, resolvable this). */
+ * validity checks (derived-class body, resolvable this). */
 export function superThisRef(lowerer, access) {
     const cls = lowerer.currentClass;
     if (!cls?.base) {
@@ -5553,8 +6480,8 @@ export function superThisRef(lowerer, access) {
     };
 }
 /** `super.x` read: a DIRECT call of the base chain's getter over this
-   * method's own `this` (upcast to the declarer) — like super.method(),
-   * never through the vtable. */
+ * method's own `this` (upcast to the declarer) — like super.method(),
+ * never through the vtable. */
 export function lowerSuperAccessorRead(lowerer, access) {
     const { thisRef, base } = lowerer.superThisRef(access);
     const name = access.name.text;
@@ -5578,7 +6505,7 @@ export function lowerSuperAccessorRead(lowerer, access) {
     };
 }
 /** `super.x = v`: a DIRECT call of the base chain's setter (same
-   * static-dispatch rule as every super member access). */
+ * static-dispatch rule as every super member access). */
 export function lowerSuperAccessorWrite(lowerer, access, rhs, loc) {
     const { thisRef, base } = lowerer.superThisRef(access);
     const name = access.name.text;
@@ -5605,9 +6532,9 @@ 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 argument rule, and their synthesized
-   * constructors forward both checked-dynamic values to error.ctorOptions. */
+ * inherited through ctor-less bases — is a builtin error class's. Such
+ * 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)
@@ -5618,7 +6545,7 @@ export function inheritsBuiltinErrorCtor(lowerer, info) {
     return false;
 }
 /** The EventEmitter twin: a ctor-less chain into the emitter base
-   * inherits `new C()` — zero arguments (the options bag fences). */
+ * inherits `new C()` — zero arguments (the options bag fences). */
 export function inheritsBuiltinEmitterCtor(lowerer, info) {
     for (let c = info; c; c = c.base) {
         if (c.builtinStream)
@@ -5631,10 +6558,10 @@ export function inheritsBuiltinEmitterCtor(lowerer, info) {
     return false;
 }
 /** The stream twin: a ctor-less chain into a runtime stream base
-   * inherits `new C()` — zero arguments (the synthesized constructor runs
-   * super() with default options; passing options through an inherited
-   * constructor would need the literal at the new-site to plumb, so it
-   * asks for a declared constructor instead). */
+ * inherits `new C()` — zero arguments (the synthesized constructor runs
+ * super() with default options; passing options through an inherited
+ * constructor would need the literal at the new-site to plumb, so it
+ * asks for a declared constructor instead). */
 function inheritsBuiltinStreamCtor(lowerer, info) {
     for (let c = info; c; c = c.base) {
         if (c.builtinStream)
@@ -5708,8 +6635,13 @@ function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
         : 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: "newValue",
+                callee: classValueRef(lowerer, info, expr),
+                args,
+                type: { kind: "object", className: info.def.name },
+                loc,
+            };
     }
     return {
         kind: "new",
@@ -5732,6 +6664,9 @@ function assignedThisFieldType(lowerer, expr) {
 }
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    const worker = lowerWorkerNew(lowerer, expr);
+    if (worker)
+        return worker;
     let intlConstructor = expr.expression;
     if (ts.isIdentifier(intlConstructor)) {
         const symbol = lowerer.resolveValueSymbol(intlConstructor);
@@ -5739,7 +6674,9 @@ export function lowerNew(lowerer, expr) {
         if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer)
             intlConstructor = declaration.initializer;
     }
-    const intl = ts.isPropertyAccessExpression(intlConstructor) ? lowerer.stdlibGlobalMember(intlConstructor, "Intl") : null;
+    const intl = ts.isPropertyAccessExpression(intlConstructor)
+        ? lowerer.stdlibGlobalMember(intlConstructor, "Intl")
+        : null;
     if (intl && intl !== "Segmenter")
         lowerer.noLowering(`new Intl.${intl}`, expr, undefined, lowerer.checker.getSymbolAtLocation(expr.expression));
     const instanceConstructor = lowerInstanceConstructorNew(lowerer, expr);
@@ -5750,10 +6687,16 @@ export function lowerNew(lowerer, expr) {
         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);
+        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)) {
+            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");
             }
         }
@@ -5767,13 +6710,24 @@ export function lowerNew(lowerer, expr) {
         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),
+            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 };
+                else_: lowerer.coerceInto(expr, lowerProgramClassNew(lowerer, expr, no, loc), type),
+                type,
+                loc,
+            };
         }
     }
-    if (ts.isPropertyAccessExpression(expr.expression) && expr.expression.name.text === "Segmenter" &&
+    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;
@@ -5781,16 +6735,24 @@ export function lowerNew(lowerer, expr) {
             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"))) {
+        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) };
+            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;
@@ -5960,8 +6922,10 @@ export function lowerNew(lowerer, expr) {
         if (agent)
             return agent;
     }
-    if (ts.isIdentifier(expr.expression) || ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.name) &&
-        lowerer.isStdlibGlobal(expr.expression.expression, "globalThis")) {
+    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).
         if (ts.isIdentifier(expr.expression))
@@ -6059,8 +7023,14 @@ export function lowerNew(lowerer, expr) {
             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 };
+                    : dynUndefinedExpr(loc));
+                return {
+                    kind: "libCall",
+                    fn: "regex.newChecked",
+                    args: checked,
+                    type: { kind: "regex" },
+                    loc,
+                };
             }
             const strArg = (a, what) => {
                 if (!a)
@@ -6070,9 +7040,18 @@ export function lowerNew(lowerer, expr) {
                 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 };
+                    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")) {
+                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") {
@@ -6082,7 +7061,13 @@ export function lowerNew(lowerer, expr) {
             };
             const pattern = strArg(args[0], "pattern");
             const flags = strArg(args[1], "flags argument");
-            return { kind: "libCall", fn: "regex.new", args: [pattern, flags], type: { kind: "regex" }, loc };
+            return {
+                kind: "libCall",
+                fn: "regex.new",
+                args: [pattern, flags],
+                type: { kind: "regex" },
+                loc,
+            };
         }
         if (symbol && symbol.name === "URL" && lowerer.isStdlibSymbol(symbol)) {
             return lowerUrlNew(lowerer, expr);
@@ -6102,9 +7087,20 @@ export function lowerNew(lowerer, expr) {
                 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 };
+                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 };
@@ -6146,7 +7142,9 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
-        if (symbol && (symbol.name === "TextDecoder" || symbol.name === "TextEncoder") && lowerer.isStdlibSymbol(symbol)) {
+        if (symbol &&
+            (symbol.name === "TextDecoder" || symbol.name === "TextEncoder") &&
+            lowerer.isStdlibSymbol(symbol)) {
             return lowerTextCodecNew(lowerer, expr, symbol.name);
         }
         // `new Uint8Array(...)` / `new Uint32Array(...)` / `new
@@ -6191,7 +7189,8 @@ export function lowerNew(lowerer, expr) {
         }
         if (symbol?.name === "Map" && lowerer.isStdlibSymbol(symbol)) {
             const seedArg = (expr.arguments?.length ?? 0) === 1 ? expr.arguments[0] : null;
-            const isPairLit = (el) => ts.isArrayLiteralExpression(el) && el.elements.length === 2 &&
+            const isPairLit = (el) => ts.isArrayLiteralExpression(el) &&
+                el.elements.length === 2 &&
                 !el.elements.some(ts.isSpreadElement);
             const entriesLit = seedArg && ts.isArrayLiteralExpression(seedArg) && seedArg.elements.every(isPairLit)
                 ? seedArg.elements.filter(isPairLit)
@@ -6212,7 +7211,8 @@ export function lowerNew(lowerer, expr) {
             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 &&
+            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
@@ -6264,7 +7264,9 @@ 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, keyIr.kind === "union" ? lowerer.unions.get(keyIr.unionId)?.arms : undefined))) {
+            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 numbers, strings, booleans, bigints, identity references, or supported unions)`);
             }
@@ -6276,19 +7278,35 @@ export function lowerNew(lowerer, expr) {
             lowerer.badType(expr, tsType);
         }
         // Weak containers share checked native key identities and lifetime hooks.
-        if ((symbol?.name === "WeakMap" || symbol?.name === "WeakSet") && lowerer.isStdlibSymbol(symbol)) {
+        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 };
+                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",
+                kind: "libCall",
+                fn: symbol.name === "WeakMap" ? "weakMap.new" : "weakSet.new",
                 args: [args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc)],
-                type: DYN, loc,
+                type: DYN,
+                loc,
             };
         }
         // `new Set<T>()`: construct + bulk add from supported values,
@@ -6304,9 +7322,21 @@ export function lowerNew(lowerer, expr) {
                 if (seeded)
                     return seeded;
             }
-            if (!mapped && isJsSourceFile(expr.getSourceFile()) && (expr.arguments?.length ?? 0) <= 1 && !expr.arguments?.some(ts.isSpreadElement)) {
-                return { kind: "libCall", fn: "dyn.nativeSetNew", args: [expr.arguments?.[0]
-                            ? lowerer.lowerExprExpecting(expr.arguments[0], DYN) : dynUndefinedExpr(loc)], type: DYN, loc };
+            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
@@ -6427,7 +7457,9 @@ export function lowerNew(lowerer, expr) {
                 lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[0]))?.kind !== "string" &&
                 lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]))?.kind === "string") {
                 const first = lowerer.lowerExpr(expr.arguments[0]);
-                if (first.kind === "unitLit" || first.type.kind === "dyn" || lowerer.dynConvertible(first.type)) {
+                if (first.kind === "unitLit" ||
+                    first.type.kind === "dyn" ||
+                    lowerer.dynConvertible(first.type)) {
                     const got = first.type.kind === "dyn" ? first : { kind: "dynFrom", value: first, type: DYN, loc };
                     // The encoding argument still evaluates in Node before the
                     // throw only via the ctor body's later reads — it does NOT
@@ -6435,7 +7467,13 @@ export function lowerNew(lowerer, expr) {
                     // effect-free operands; effectful ones keep the fence.
                     const enc = lowerer.lowerExpr(expr.arguments[1]);
                     if (enc.kind === "strLit" || isSafeToRepeat(enc)) {
-                        return { kind: "libCall", fn: "buffer.newStringFail", args: [got], type: bytesOf("u8"), loc };
+                        return {
+                            kind: "libCall",
+                            fn: "buffer.newStringFail",
+                            args: [got],
+                            type: bytesOf("u8"),
+                            loc,
+                        };
                     }
                 }
             }
@@ -6490,10 +7528,10 @@ export function lowerNew(lowerer, expr) {
             if (t?.kind !== "record")
                 lowerer.badType(expr, lowerer.typeOf(expr));
             const key = `x509.record:${isBytes ? "bytes" : "str"}`;
-            let helper = lowerer.widthHelpers.get(key);
+            let helper = lowerer.valueHelpers.get(key);
             if (!helper) {
-                helper = `%x509.record.${lowerer.widthHelpers.size}`;
-                lowerer.widthHelpers.set(key, helper);
+                helper = `%x509.record.${lowerer.valueHelpers.size}`;
+                lowerer.valueHelpers.set(key, helper);
                 const dataT = data.type;
                 const dRef = { kind: "varRef", localId: "d.0", type: dataT, loc };
                 const field = (name, fn) => ({
@@ -6539,7 +7577,9 @@ export function lowerNew(lowerer, expr) {
         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)) {
+            if (!info &&
+                ts.isPropertyAccessExpression(expr.expression) &&
+                ts.isIdentifier(expr.expression.name)) {
                 // A property-assigned class expression not collected yet (this
                 // body lowers ahead of the assignment statement — hoisted
                 // functions): collect it on demand and retry, keeping the
@@ -6590,7 +7630,8 @@ export function lowerNew(lowerer, expr) {
         if (calleeT?.kind === "union") {
             const def = lowerer.unions.get(calleeT.unionId);
             if (def?.arms.some((a) => a.kind === "classval")) {
-                if (def.arms.every((arm) => arm.kind === "classval" || isJsSourceFile(expr.getSourceFile()) && isUnitType(arm)) && lowerer.dynConvertible(calleeT)) {
+                if (def.arms.every((arm) => arm.kind === "classval" || (isJsSourceFile(expr.getSourceFile()) && isUnitType(arm))) &&
+                    lowerer.dynConvertible(calleeT)) {
                     const callee = lowerer.lowerExprExpecting(expr.expression, DYN);
                     return lowerCheckedConstructor(lowerer, expr, callee);
                 }
@@ -6621,7 +7662,10 @@ export function lowerNew(lowerer, expr) {
     }
     // Checked construction supports emitted classes and builtin typed arrays.
     const callee = tryLowerExpression(lowerer, expr.expression);
-    if (callee && (callee.type.kind === "dyn" || (callee.type.kind === "func" || callee.type.kind === "classval") && lowerer.dynConvertible(callee.type))) {
+    if (callee &&
+        (callee.type.kind === "dyn" ||
+            ((callee.type.kind === "func" || callee.type.kind === "classval") &&
+                lowerer.dynConvertible(callee.type)))) {
         return lowerCheckedConstructor(lowerer, expr, lowerer.coerceToExpected(callee, DYN));
     }
     lowerer.unsupported("SC1090", expr, "constructing values other than classes declared in the program");
@@ -6636,10 +7680,10 @@ function lowerCheckedConstructor(lowerer, expr, callee) {
     return checkedClassConstruction(lowerer, callee, args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
 }
 /** A getter/setter invocation over an accessor target's receiver — the
-   * same whole-program devirtualization as method calls: a virtualCall
-   * when some strict subclass of the receiver's static class overrides
-   * this HALF of the accessor (get and set devirtualize independently),
-   * a direct call of the nearest declaration otherwise. */
+ * same whole-program devirtualization as method calls: a virtualCall
+ * when some strict subclass of the receiver's static class overrides
+ * this HALF of the accessor (get and set devirtualize independently),
+ * a direct call of the nearest declaration otherwise. */
 export function accessorCall(lowerer, className, member, obj, extraArgs, ret, loc) {
     const info = lowerer.classes.get(className);
     if (!info)
@@ -6687,7 +7731,8 @@ function genericFieldFnNodeOf(member) {
     while (ts.isParenthesizedExpression(init))
         init = init.expression;
     if ((ts.isArrowFunction(init) || ts.isFunctionExpression(init)) &&
-        init.typeParameters !== undefined && init.body !== undefined) {
+        init.typeParameters !== undefined &&
+        init.body !== undefined) {
         return init;
     }
     return null;