@scriptc/compiler 0.2.5 → 0.2.7

package/dist/frontend/lowering/lower-classes.d.ts

@@ -2,6 +2,7 @@ import * as ts from "../ts7/adapter.js";
 import type { FnCtx, Lowerer } from "./lowerer.js";
 import { type IrClassDef, type IrExpr, type IrFunction, type IrLocal, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
 import { type GenericFnInfo } from "./generic-functions.js";
+import { type InstantiationPath } from "./instantiation-path.js";
 import { type ParamShape } from "./call-signatures.js";
 import { type ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type EmitOverrideRec } from "./lower-event-emitter.js";
@@ -131,6 +132,8 @@ export interface ClassInfo {
      * (forwarding the completed ABI values; defaults apply in the base). */
     ctorParams: ParamShape[];
     base: ClassInfo | null;
+    /** Family heritage resolves its type arguments separately for each instance. */
+    genericBase?: ts.ExpressionWithTypeArguments;
     /** A module class may inherit a compiled ordinary JS constructor. Its
      * callable and prototype are captured when the class declaration runs. */
     callableBase?: {
@@ -161,6 +164,8 @@ export interface ClassInfo {
     staticFields: {
         name: string;
         type: IrType;
+        /** Indexed sources can be absent despite the declared static type. */
+        runtimeOptional?: true;
         initializer: ts.Expression;
         globalId: string;
         readonly: boolean;
@@ -214,6 +219,7 @@ export interface ClassInfo {
      * counts statements toward coverage — re-instantiations re-visit the
      * same source lines). */
     genericInstance?: {
+        path: InstantiationPath;
         family: ClassInfo;
         bindings: Map<ts.Symbol, IrType>;
         typeArgsText: string;
@@ -376,6 +382,7 @@ export declare function guaranteedDecorationThrow(lowerer: Lowerer, decl: ts.Cla
 } | null;
 export declare function collectClassShape(lowerer: Lowerer, decl: ts.ClassDeclaration): void;
 export declare function collectClassShapeInner(lowerer: Lowerer, decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
+    path: InstantiationPath;
     family: ClassInfo;
     name: string;
     bindings: Map<ts.Symbol, IrType>;

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

@@ -1,4 +1,5 @@
 import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
+import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
  * (fields, methods, accessors, overrides), constructor/member lowering with
@@ -7,7 +8,8 @@ import { InternalCompilerError } from "../../errors.js";
  * hierarchy registration. */
 import * as ts from "../ts7/adapter.js";
 import { BOOL, DATE_T, DYN, F64, bytesOf, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
-import { MAX_GENERIC_INSTANCES, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, } from "./generic-functions.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";
@@ -22,6 +24,7 @@ import { bufEncoding } from "./containers/bytes.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { lowerSearchParamsNew } from "./builtins/url.js";
 import { lowerTextCodecNew } from "./builtins/text-codecs.js";
+import { 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";
@@ -378,6 +381,10 @@ export function registerBuiltinErrorClasses(lowerer) {
                     { name: "%nameEnumerable", type: BOOL },
                     { name: "%stackFrames", type: STRING },
                     { name: "%stack", type: STRING },
+                    { name: "%systemErrno", type: F64 },
+                    { name: "%systemCall", type: STRING },
+                    { name: "%systemPath", type: STRING },
+                    { name: "%systemDest", type: STRING },
                 ],
                 loc,
             },
@@ -949,7 +956,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)
@@ -1212,18 +1248,16 @@ 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 genericBase;
         let callableBase;
         let factoryBaseExpression;
         const adoptCallableBase = (expression) => {
@@ -1250,35 +1284,12 @@ mixin) {
             };
             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
@@ -1288,6 +1299,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)) {
@@ -1669,6 +1696,7 @@ mixin) {
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
                     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");
@@ -1860,8 +1888,8 @@ mixin) {
                 // declaration is an ordinary OWN field (tsc guarantees every
                 // instantiable subclass declares it and, under
                 // strictPropertyInitialization, initializes it). Reads through
-                // ABSTRACT-typed receivers have no slot to read and keep a
-                // per-site fence.
+                // ABSTRACT-typed receivers resolve the concrete instance's
+                // property through checked class dispatch.
                 if (modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword))
                     continue;
                 if (modifiers?.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)) {
@@ -1899,7 +1927,9 @@ mixin) {
                             : null;
                     if (!type ||
                         type.kind === "void" ||
-                        (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile())))
+                        (type.kind === "dyn" &&
+                            !isJsSourceFile(member.getSourceFile()) &&
+                            !lowerer.classImplementedProtocol(inferred)))
                         lowerer.badType(member, inferred);
                     if (isJsSourceFile(member.getSourceFile())) {
                         type = inheritedJsFieldType(lowerer, decl, fieldName, type);
@@ -2027,7 +2057,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;
@@ -2155,7 +2187,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
@@ -2207,15 +2239,12 @@ mixin) {
                     if (findGenericMethodOn(lowerer, base, mName)) {
                         lowerer.unsupported("SC1090", member.name, `overriding the inherited generic method '${mName}' with a non-generic method (generic methods dispatch statically and would never reach this override)`);
                     }
-                    // Abstract re-declarations keep the overridden ABI exactly,
-                    // like any override (a concrete implementation below must
-                    // agree with BOTH, which exactness makes one constraint).
                     const overridden = lowerer.findMethodOn(base, mName);
                     if (overridden &&
                         (overridden.sig.params.length !== shapes.length ||
                             !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
-                            !typeEquals(overridden.sig.ret, ret))) {
-                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                            !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ret, overridden.sig.ret, className, base)))) {
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
                     methods.set(mName, { params: shapes, ret, abstract: true });
                     continue;
@@ -2336,11 +2365,12 @@ mixin) {
                     if (refined)
                         ft.ret = refined;
                 }
-                // Overrides keep the EXACT overridden ABI signature. tsc's method
+                // Overrides keep the inherited ABI signature. tsc's method
                 // bivariance would let a narrowed parameter type through, and a
                 // vtable-dispatched call could then hand the override a base
                 // instance it reads out-of-bounds fields from — exactness keeps
-                // every slot sound (covariant returns can come later). Comparing
+                // every parameter slot sound. Nominal covariant returns share the
+                // base pointer ABI while retaining their declared result type. Comparing
                 // ABI types only (not modes) is deliberate: call sites complete
                 // against the STATIC receiver's shape, so `m(x?: number)` and
                 // `m(x: number | undefined)` interchange soundly in overrides.
@@ -2402,7 +2432,7 @@ mixin) {
                     member.asteriskToken === undefined &&
                     (overridden.sig.params.length !== shapes.length ||
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
-                        !typeEquals(overridden.sig.ret, ft.ret))) {
+                        !typeEquals(overridden.sig.ret, overrideReturnAbi(lowerer, ft.ret, overridden.sig.ret, className, base)))) {
                     const fencedJsOverride = isJsSourceFile(member.getSourceFile()) &&
                         overridden.declarer.decl !== null &&
                         isJsSourceFile(overridden.declarer.decl.getSourceFile()) &&
@@ -2429,12 +2459,12 @@ mixin) {
                             });
                         methodEntryFences.set(mName, unsupportedDiag("SC1090", locOf(member.name), returnOnly
                             ? `overriding method '${mName}' with a different return type (the native return type must match the base declaration exactly)`
-                            : `overriding method '${mName}' with a different signature (the native parameter and return types must match the base declaration exactly)`));
+                            : `overriding method '${mName}' with a different signature (the native parameter types must match the base declaration exactly; returns may narrow to a subclass)`));
                         shapes.splice(0, shapes.length, ...overridden.sig.params);
                         ft.ret = overridden.sig.ret;
                     }
                     else {
-                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter types must match the base declaration exactly; returns may narrow to a subclass)");
                     }
                 }
                 const asyncMember = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
@@ -3015,6 +3045,7 @@ mixin) {
             ctorParams,
             ...(paramProps.length > 0 ? { paramProps } : {}),
             base,
+            ...(genericBase ? { genericBase } : {}),
             ...(callableBase ? { callableBase } : {}),
             ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
@@ -3044,6 +3075,7 @@ mixin) {
         }
         if (inst) {
             info.genericInstance = {
+                path: inst.path,
                 family: inst.family,
                 bindings: inst.bindings,
                 typeArgsText: inst.typeArgsText,
@@ -3146,7 +3178,14 @@ mixin) {
  * 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
@@ -3203,12 +3242,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 };
@@ -3219,10 +3258,13 @@ 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, {
+            path,
             family: gci.family,
             name,
             bindings,
@@ -3241,6 +3283,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) {
@@ -3290,6 +3333,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;
@@ -3300,6 +3345,7 @@ 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
@@ -3896,7 +3942,13 @@ export function lowerStaticFieldRead(lowerer, expr) {
         lowerer.unsupported("SC1090", expr, `reading the private static '${expr.name.text}' 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 (found?.field !== undefined) {
-        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        const value = {
+            kind: "varRef",
+            localId: found.field.globalId,
+            type: found.field.type,
+            loc,
+        };
+        return found.field.runtimeOptional ? value : lowerer.maybeNarrow(value, expr);
     }
     if (found) {
         return staticMethodValue(lowerer, found.declarer, expr.name.text, found.method, expr, loc);
@@ -4420,6 +4472,19 @@ 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.
@@ -4696,7 +4761,13 @@ export function lowerClassValueProperty(lowerer, expr) {
         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) {
-        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        const value = {
+            kind: "varRef",
+            localId: found.field.globalId,
+            type: found.field.type,
+            loc,
+        };
+        return found.field.runtimeOptional ? value : lowerer.maybeNarrow(value, expr);
     }
     return staticMethodValue(lowerer, found.declarer, member, found.method, expr, loc);
 }
@@ -4714,6 +4785,20 @@ function abstractMemberSignature(lowerer, member) {
         ret: lowerer.declaredReturnType(member, member.name),
     };
 }
+/** A nominal return subtype uses the same owned pointer as the inherited
+ * return slot. The current class is still being collected, so consult its
+ * already collected base chain before the complete class graph is available. */
+function overrideReturnAbi(lowerer, declared, inherited, className, base) {
+    if (declared.kind !== "object" || inherited.kind !== "object")
+        return declared;
+    if (lowerer.isSubclassOf(declared.className, inherited.className) ||
+        (declared.className === className &&
+            base !== null &&
+            (base.def.name === inherited.className ||
+                lowerer.isSubclassOf(base.def.name, inherited.className))))
+        return inherited;
+    return declared;
+}
 /** The nearest declaration of `name` at or above `info` — the method a
  * receiver of that static class runs when nothing below overrides it. */
 export function findMethodOn(lowerer, info, name) {
@@ -4726,9 +4811,15 @@ 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;
 }
@@ -4871,34 +4962,7 @@ export function collectInheritedJsFieldWrites(lowerer, files) {
  * hierarchy identifies the original declarations through aliases as well. */
 export function collectVirtualJsMethods(lowerer, files) {
     const families = [];
-    // Record named prototype accesses before collecting method signatures.
-    // Those slots need a callable ABI even when JavaScript would otherwise
-    // specialize each call independently.
-    for (const file of files)
-        ts.walkPreorder(file, (node) => {
-            if (!ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
-                return;
-            const name = ts.isPropertyAccessExpression(node)
-                ? node.name.text
-                : ts.isStringLiteralLike(node.argumentExpression)
-                    ? node.argumentExpression.text
-                    : null;
-            if (name === null)
-                return;
-            const prototype = ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "prototype";
-            const assigned = ts.isBinaryExpression(node.parent) &&
-                node.parent.left === node &&
-                node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
-            const symbol = !assigned
-                ? undefined
-                : ts.isPropertyAccessExpression(node)
-                    ? lowerer.checker.getSymbolAtLocation(node.name)
-                    : lowerer.checker.getPropertyOfType(lowerer.typeOf(node.expression), name);
-            if (prototype ||
-                (symbol && lowerer.checker.declarationsOf(symbol).some(ts.isMethodDeclaration))) {
-                lowerer.prototypeMethodAccesses.set(name, node);
-            }
-        });
+    collectClassMethodMutations(lowerer, files);
     const visit = (node) => {
         if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
             const accessors = node.members.filter((member) => (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) &&
@@ -5065,7 +5129,7 @@ export function exactInstanceClassOf(lowerer, expr) {
  * 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;
@@ -5076,13 +5140,16 @@ 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
@@ -6599,6 +6666,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);
@@ -7205,7 +7275,7 @@ export function lowerNew(lowerer, expr) {
             if (targs[1]) {
                 lowerer.unsupported("SC1090", expr, `Map values of type '${lowerer.checker.typeToString(targs[1])}' ` +
                     `(Map values must be number, string, boolean, records, class instances, ` +
-                    `arrays, promises, Maps, Sets, or unions of those — not functions, 'unknown', or 'any')`);
+                    `typed arrays, arrays, promises, Maps, Sets, or supported unions and checked values)`);
             }
             lowerer.badType(expr, tsType);
         }