@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -1,3 +1,7 @@
+import { DATE_TIME_FIELD, dateRootOf, dateSuperCall, isDatePrototypeMethod, lowerDateSuperMethodCall, } from "./builtins/date-classes.js";
+import { predeclareForwardClass } from "./lower-stmts.js";
+import { lowerDateStaticCall } from "./builtins/dates.js";
+import { keyedHelperName } from "./stable-names.js";
 import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js";
 import { adaptPromiseExecutor } from "./promise-executor-adapter.js";
 import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js";
@@ -29,7 +33,7 @@ import { bodyReadsArguments } from "../arguments-usage.js";
 import { errorNameAfterField, errorViewFields } from "./error-name-order.js";
 import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, } from "./call-signatures.js";
 import { omittedArgFor } from "./call-arguments.js";
-import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
+import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
 import { canonicalBuiltinModule, cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, locOf, requireSpecOf, } from "../program.js";
 import { PoisonError, dynFallbackType, jsFuncNameOf, newFnCtx, own } from "./lowerer.js";
 import { isAssertClassNew } from "./assert-instances.js";
@@ -43,19 +47,19 @@ import { lowerSearchParamsNew } from "./builtins/url.js";
 import { lowerTextCodecNew } from "./builtins/text-codecs.js";
 import { lowerBroadcastChannelNew, lowerMessageChannelNew, lowerWorkerNew, } from "./builtins/workers.js";
 import { unsupportedPackageValueDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.js";
-import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, STREAM_COMPLETION_CALLBACK_INDEX, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
+import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, STREAM_COMPLETION_CALLBACK_INDEX, UNDERSCORE_METHODS, streamExtraCallbacks, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
 import { builtinEventTargetBaseOf, eventTargetApiMembers, eventTargetApiMethod, eventTargetRootOf, eventTargetSuperCall, lowerEventTargetMethodCall, } from "./lower-event-target.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 { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js";
+import { lowerHttpAgentNew, lowerHttpServerNew, lowerTlsSocketNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, 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";
 import { isNativeProxyInitializer, lowerNativeProxy } from "./expressions/native-proxy.js";
 import { classStaticDataFor } from "./class-static-data.js";
-import { construction, constructionPrefix } from "./js-class-fields.js";
+import { accessorInterceptsBase, accessorNames, construction, constructionPrefix, } from "./js-class-fields.js";
 import { lowerObjectFactoryNew } from "./object-factory-new.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.js";
@@ -64,6 +68,7 @@ import { constructionEscape } from "./construction-escapes.js";
 import { checkedClassConstruction, checkedClassConstructionPacked } from "./class-construction.js";
 import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js";
 import { reflectedClassStaticMethodValue } from "./class-method-values.js";
+import { identifierReadSymbol } from "./surfaces.js";
 export function returnsOnlyThis(member) {
     const body = member.body;
     const last = body?.statements?.nodes.at(-1);
@@ -119,7 +124,7 @@ export function returnsOnlyThisValue(member) {
     ts.forEachChild(body, visit);
     return valid;
 }
-function functionLocalClass(decl) {
+export function functionLocalClass(decl) {
     for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
         if (ts.isFunctionLike(parent))
             return true;
@@ -493,8 +498,10 @@ export function registerBuiltinErrorClasses(lowerer) {
             throwingSetters: [],
             staticFields: [],
         };
-        if (base)
+        if (base) {
             base.subclasses.push(info);
+            lowerer.subclassLinks++;
+        }
         lowerer.classes.set(irName, info);
     }
 }
@@ -575,8 +582,10 @@ export function registerBuiltinStreamClasses(lowerer) {
             throwingSetters: [],
             staticFields: [],
         };
-        if (base)
+        if (base) {
             base.subclasses.push(info);
+            lowerer.subclassLinks++;
+        }
         lowerer.classes.set(irName, info);
     }
 }
@@ -1358,6 +1367,7 @@ mixin) {
                 : (computedBase?.classInfo ?? null);
         let genericBase;
         let callableBase;
+        let extendsDate = false;
         let factoryBaseExpression;
         const adoptCallableBase = (expression) => {
             if (familyMode || inst || mixin)
@@ -1538,6 +1548,12 @@ mixin) {
                     continue;
                 lowerer.unsupported("SC1090", clause, "extending computed expressions");
             }
+            if (!familyMode && !inst && !mixin && lowerer.isStdlibGlobal(t.expression, "Date")) {
+                if (t.typeArguments?.nodes)
+                    lowerer.unsupported("SC1090", t, "extending generic classes");
+                extendsDate = true;
+                continue;
+            }
             const symbol = lowerer.resolveValueSymbol(t.expression);
             // Extending a REBINDABLE decorated class (analysis already ran —
             // this collection is a class expression or a generic
@@ -1679,6 +1695,7 @@ mixin) {
         // receiver-sensitive getters and setters inherited by subclasses.
         const checkedStatics = isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             ((base && hasRuntimeStatics(base)) ||
+                definedThroughReflection(lowerer, decl) ||
                 decl.members.nodes.some((member) => ts.isAccessor(member) &&
                     !ts.isPrivateIdentifier(member.name) &&
                     member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
@@ -1738,7 +1755,8 @@ mixin) {
         };
         for (const member of decl.members.nodes) {
             if ((functionLocalClass(decl) || checkedStatics) &&
-                isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+                (isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
+                    (functionLocalClass(decl) && ts.isMethodDeclaration(member))) &&
                 (ts.isClassStaticBlockDeclaration(member) ||
                     ts
                         .getModifiers(member)
@@ -1992,8 +2010,8 @@ mixin) {
             // state, so an override or shadowing field would split-brain.
             // Underscore methods are the SUPPORTED override form — but only
             // the ones the class's own base consumes (a `_read` on a
-            // Transform, or `_writev`/`_construct` anywhere, would be consumed
-            // by Node machinery that has no lowering here).
+            // Transform, or `_writev` on a Readable, would be consumed by Node
+            // machinery that has no lowering here).
             if (memberName && ts.isIdentifier(memberName)) {
                 const streamBase = (() => {
                     for (let c = base; c; c = c.base)
@@ -2006,8 +2024,8 @@ mixin) {
                     if (STREAM_API_MEMBERS.has(name) || STREAM_PROP_MEMBERS.has(name)) {
                         lowerer.unsupported("SC1090", memberName, `overriding the stream member '${name}' (the runtime owns the stream surface)`);
                     }
-                    if (name === "_writev" || name === "_construct") {
-                        lowerer.unsupported("SC1090", memberName, `declaring '${name}' on a stream subclass (${name === "_writev" ? "batched writes are" : "deferred construction is"} not lowered — writes deliver one chunk at a time)`);
+                    if (name === "_writev" && !streamExtraCallbacks(streamBase.def.name).includes("writev")) {
+                        lowerer.unsupported("SC1090", memberName, `declaring '_writev' on a ${streamBase.def.name.slice(1)} subclass (a Readable has no writable side)`);
                     }
                     const accepted = streamCtorShape(streamBase.def.name).accepted;
                     for (const [option, methodName] of UNDERSCORE_METHODS) {
@@ -3152,7 +3170,7 @@ mixin) {
             }
             // A subclass field created before anything can observe the instance
             // keeps its type: super() cannot run code that reads it earlier.
-            const baseConstruction = base && ![...methods.keys()].some((m) => m.startsWith("get:") || m.startsWith("set:"))
+            const baseConstruction = base && !accessorInterceptsBase(accessorNames(methods.keys()), base)
                 ? construction(base)
                 : null;
             const sealedPrefix = baseConstruction
@@ -3180,7 +3198,7 @@ mixin) {
                             // An own JS callable shadows its prototype declaration.
                             // Keep the method in the prototype and store the assigned
                             // value in the instance property bag.
-                            lowerer.prototypeMethodAccesses.set(name, assign);
+                            lowerer.noteMethodAccess(name, assign);
                             continue;
                         }
                         const sym = lowerer.checker.getSymbolAtLocation(assign);
@@ -3257,7 +3275,7 @@ mixin) {
                         if (!key && (fields.has(fieldName) || hasAccessor(fieldName)))
                             continue;
                         if (!key && (methods.has(fieldName) || lowerer.findMethodOn(base, fieldName))) {
-                            lowerer.prototypeMethodAccesses.set(fieldName, lhs);
+                            lowerer.noteMethodAccess(fieldName, lhs);
                             continue;
                         }
                         // A key already declared (own or inherited) makes later
@@ -3394,7 +3412,8 @@ mixin) {
         // synthesized constructor forwards the same params to super).
         const ctorParams = ctor && !mixinForwarding
             ? lowerer.paramShapes(ctor.parameters.nodes)
-            : (base?.ctorParams ?? (callableBase ? [{ type: DYN, mode: "dynRest" }] : []));
+            : (base?.ctorParams ??
+                (callableBase || extendsDate ? [{ type: DYN, mode: "dynRest" }] : []));
         if (ctor &&
             !mixinForwarding &&
             isJsSourceFile(ts.getSourceFileOfNode(ctor)) &&
@@ -3421,6 +3440,7 @@ mixin) {
                 // Redeclared INHERITED fields contribute no slot (their
                 // initializers assign the prefix slot).
                 fields: [
+                    ...(extendsDate ? [{ name: DATE_TIME_FIELD, type: DATE_T }] : []),
                     ...(base?.def.fields ?? []),
                     ...fieldOrder
                         .filter((f) => f.redeclared !== true)
@@ -3452,6 +3472,7 @@ mixin) {
             base,
             ...(genericBase ? { genericBase } : {}),
             ...(callableBase ? { callableBase } : {}),
+            ...(extendsDate ? { extendsDate: true } : {}),
             ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
             throwingSetters,
@@ -3492,6 +3513,7 @@ mixin) {
                 path: inst.path,
                 family: inst.family,
                 bindings: inst.bindings,
+                tsBindings: inst.tsBindings,
                 typeArgsText: inst.typeArgsText,
                 ordinal: inst.ordinal,
             };
@@ -3522,8 +3544,10 @@ mixin) {
             };
             lowerer.genericClassByDecl.set(decl, info.generic);
         }
-        if (base)
+        if (base) {
             base.subclasses.push(info);
+            lowerer.subclassLinks++;
+        }
         lowerer.classes.set(className, info);
         if (computedBase && !functionLocalClass(decl)) {
             info.def.baseValueGlobal = `%g.${className}.computedBase`;
@@ -3625,8 +3649,10 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
         .getTypeArguments(ref)
         .slice(0, gci.typeParams.length);
     const mapped = [];
+    const tsArgs = [];
     if (args.length === gci.typeParams.length) {
         for (const a of args) {
+            tsArgs.push(lowerer.typeParamTsResolver(a) ?? a);
             const m = lowerer.mapTypeOf(a, mapArgument);
             if (!m || m.kind === "void") {
                 // An UNBOUND type parameter argument (`Box<T>` outside any
@@ -3647,9 +3673,34 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
             if (!b)
                 return null;
             mapped.push(b);
-        }
-    }
-    const key = mapped.map(typeKey).join(",");
+            const bound = lowerer.typeParamTsBindings?.get(tp);
+            if (bound)
+                tsArgs.push(bound);
+        }
+    }
+    // A type parameter that a conditional type in the class depends on
+    // (`K extends "required" ? T : T | undefined`) is bound to its checker
+    // type for the members, and that type keys the instance: mapType alone
+    // widens a literal, so Field<string, "required"> and Field<string,
+    // "optional"> would otherwise share one layout. The other parameters get
+    // no checker binding, so nothing in the members depends on a literal
+    // the key does not carry.
+    gci.literalSensitive ??= literalSensitiveTypeParams(lowerer, gci);
+    const sensitive = (i) => tsArgs.length === gci.typeParams.length && gci.literalSensitive.has(gci.typeParams[i]);
+    const checkerKey = gci.typeParams
+        .map((_, i) => (sensitive(i) ? `#${tsArgs[i].id}` : "*"))
+        .join(",");
+    const key = mapped.map(typeKey).join(",") + (gci.literalSensitive.size > 0 ? `@${checkerKey}` : "");
+    const literalText = (i) => {
+        const arg = sensitive(i) ? tsArgs[i] : undefined;
+        if (arg?.isStringLiteralType())
+            return JSON.stringify(arg.value);
+        if (arg?.isNumberLiteralType())
+            return String(arg.value);
+        if (arg && arg.flags & ts.TypeFlags.BooleanLiteral)
+            return lowerer.checker.typeToString(arg);
+        return null;
+    };
     const existing = gci.instances.get(key);
     if (existing) {
         if (existing.info)
@@ -3663,18 +3714,40 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
         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}`;
+    // The name does not take the checker type ids of the key: a literal
+    // argument is named by its text, another checker type by its
+    // description. Two keys that still describe alike number the later one.
+    const nameKey = mapped.map(typeKey).join(",") +
+        (gci.literalSensitive.size > 0
+            ? `@${gci.typeParams
+                .map((_, i) => sensitive(i)
+                ? (literalText(i) ?? checkerTypeDescription(tsArgs[i], lowerer.typeCtx))
+                : "*")
+                .join(",")}`
+            : "");
+    const prefix = `${gci.family.def.name}%`;
+    const taken = new Set([...gci.instances.values()].map((instance) => instance.name));
+    let name = keyedHelperName(lowerer, prefix, nameKey, "");
+    for (let n = 1; taken.has(name); n++)
+        name = keyedHelperName(lowerer, prefix, `${nameKey}#${n}`, "");
     const entry = { name, info: null };
     gci.instances.set(key, entry);
     const bindings = new Map();
     gci.typeParams.forEach((tp, i) => bindings.set(tp, mapped[i]));
-    const rendered = mapped.map((m) => lowerer.fmt(m)).join(", ");
+    const tsBindings = new Map();
+    gci.typeParams.forEach((tp, i) => {
+        if (sensitive(i))
+            tsBindings.set(tp, tsArgs[i]);
+    });
+    const rendered = mapped.map((m, i) => literalText(i) ?? lowerer.fmt(m)).join(", ");
     const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`;
     const prevBindings = lowerer.typeParamBindings;
+    const prevTsBindings = lowerer.typeParamTsBindings;
     const prevContext = lowerer.instantiationContext;
     const previousPath = lowerer.genericInstantiationPath;
     lowerer.genericInstantiationPath = path;
     lowerer.typeParamBindings = bindings;
+    lowerer.typeParamTsBindings = tsBindings;
     lowerer.instantiationContext = `instantiating class '${gci.baseName}' with ${typeArgsText}`;
     try {
         lowerer.collectClassShapeInner(decl, undefined, {
@@ -3682,6 +3755,7 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
             family: gci.family,
             name,
             bindings,
+            tsBindings,
             typeArgsText,
             ordinal,
         });
@@ -3696,6 +3770,7 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     }
     finally {
         lowerer.typeParamBindings = prevBindings;
+        lowerer.typeParamTsBindings = prevTsBindings;
         lowerer.instantiationContext = prevContext;
         lowerer.genericInstantiationPath = previousPath;
     }
@@ -3710,6 +3785,65 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     lowerer.onLateClassCollected?.(info);
     return { kind: "object", className: name };
 }
+/** The class's type parameters that a conditional type inside it depends
+ * on: the parameters named within a type node that is a conditional type
+ * or reaches one through the type aliases and interfaces it refers to
+ * (`get(): Value<T, K>` with `type Value<T, K> = K extends "required" ? T
+ * : T | undefined`, also when the alias wraps the conditional in a union
+ * or another alias). Their arguments pick the conditional's branch. */
+function literalSensitiveTypeParams(lowerer, gci) {
+    const params = new Set(gci.typeParams);
+    const found = new Set();
+    const reaches = new Map();
+    const declarationsReach = (symbol) => {
+        const target = symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol;
+        const known = reaches.get(target);
+        if (known !== undefined)
+            return known;
+        reaches.set(target, false); // a recursive alias reaches through its other parts
+        const result = target.declarations.some((d) => ts.isTypeAliasDeclaration(d)
+            ? reachesConditional(d.type)
+            : ts.isInterfaceDeclaration(d)
+                ? d.members.nodes.some(reachesConditional)
+                : false);
+        reaches.set(target, result);
+        return result;
+    };
+    const reachesConditional = (node) => {
+        if (ts.isConditionalTypeNode(node))
+            return true;
+        if (ts.isTypeReferenceNode(node)) {
+            const name = ts.isIdentifier(node.typeName) ? node.typeName : node.typeName.right;
+            const symbol = lowerer.checker.getSymbolAtLocation(name);
+            if (symbol && !params.has(symbol) && declarationsReach(symbol))
+                return true;
+        }
+        let found = false;
+        ts.forEachChild(node, (child) => {
+            if (!found && reachesConditional(child))
+                found = true;
+        });
+        return found;
+    };
+    const collect = (node) => {
+        if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(node.typeName);
+            if (symbol && params.has(symbol))
+                found.add(symbol);
+        }
+        ts.forEachChild(node, collect);
+    };
+    const visit = (node) => {
+        if (ts.isTypeNode(node) && reachesConditional(node)) {
+            collect(node);
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    for (const member of gci.decl.members.nodes)
+        visit(member);
+    return found;
+}
 /** 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.
@@ -3745,11 +3879,13 @@ function withInstanceBindings(lowerer, info, fn) {
         }
     }
     const prevBindings = lowerer.typeParamBindings;
+    const prevTsBindings = lowerer.typeParamTsBindings;
     const prevContext = lowerer.instantiationContext;
     const prevSuppress = lowerer.suppressStats;
     const previousPath = lowerer.genericInstantiationPath;
     lowerer.genericInstantiationPath = gi.path;
     lowerer.typeParamBindings = gi.bindings;
+    lowerer.typeParamTsBindings = gi.tsBindings;
     lowerer.instantiationContext = `instantiating class '${gi.family.generic?.baseName ?? info.def.jsName ?? ""}' with ${gi.typeArgsText}`;
     lowerer.suppressStats = prevSuppress || gi.ordinal > 0;
     try {
@@ -3757,6 +3893,7 @@ function withInstanceBindings(lowerer, info, fn) {
     }
     finally {
         lowerer.typeParamBindings = prevBindings;
+        lowerer.typeParamTsBindings = prevTsBindings;
         lowerer.instantiationContext = prevContext;
         lowerer.suppressStats = prevSuppress;
         lowerer.genericInstantiationPath = previousPath;
@@ -4295,7 +4432,13 @@ export function classValueRef(lowerer, info, blame) {
     const display = info.def.name.replace(/^%|^%m\d+\./, "");
     fenceDecorationThrows(lowerer, info, blame);
     if (info.localClass && ts.isIdentifier(blame)) {
-        const stored = lowerer.resolveLocal(blame);
+        let stored = lowerer.resolveLocal(blame);
+        // A reference from a function hoisted above the class statement.
+        if (!stored) {
+            const symbol = lowerer.resolveValueSymbol(blame);
+            if (symbol && predeclareForwardClass(lowerer, symbol))
+                stored = lowerer.resolveLocal(blame);
+        }
         if (stored)
             return lowerer.coerceToExpected({ kind: "varRef", localId: stored.id, type: stored.type, loc: locOf(blame) }, { kind: "classval", className: info.def.name });
     }
@@ -4484,6 +4627,13 @@ export function lowerStaticFieldRead(lowerer, expr) {
         return null;
     const loc = locOf(expr);
     const found = findStaticOn(lowerer, info, expr.name.text);
+    // A Date static read as a value through a class declared `extends Date`:
+    // the statics lower only as calls.
+    if (!found &&
+        dateRootOf(info) &&
+        ["now", "parse", "UTC"].includes(expr.name.text) &&
+        !(ts.isCallExpression(expr.parent) && expr.parent.expression === expr))
+        lowerer.noLowering(`Date.${expr.name.text} read through a class that extends Date`, expr);
     if (hasRuntimeStatics(info) && !found?.field)
         return {
             kind: "dynKeyGet",
@@ -4687,9 +4837,10 @@ export function lowerClassExpressionInfo(lowerer, expr) {
             expr.members.nodes.some((member) => decoratorNodesOf(member).length ||
                 (!isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
                     (ts.isClassStaticBlockDeclaration(member) ||
-                        ts
-                            .getModifiers(member)
-                            ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) ||
+                        (!ts.isMethodDeclaration(member) &&
+                            ts
+                                .getModifiers(member)
+                                ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword)))) ||
                 (ts.isMethodDeclaration(member) && member.typeParameters?.nodes.length)))) {
         lowerer.unsupported("SC1090", expr, "function-local classes with statics, decorators, or generic members");
     }
@@ -4775,6 +4926,31 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     }
     return info;
 }
+/** True when a named class expression's body refers to the class value by
+ * its own name (`class Box { static of() { return new Box(); } }`, a
+ * shorthand property `{ Box }` included); type annotations naming it
+ * (`again(): Box`) do not count. */
+function classExpressionNamesItself(lowerer, expr) {
+    const name = expr.name;
+    if (!name)
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(name);
+    if (!symbol)
+        return false;
+    let found = false;
+    for (const member of expr.members.nodes) {
+        ts.walkPreorder(member, (n) => {
+            if (found || ts.isTypeNode(n))
+                return "skip";
+            if (ts.isIdentifier(n) && n.text === name.text && identifierReadSymbol(lowerer, n) === symbol)
+                found = true;
+            return undefined;
+        });
+        if (found)
+            return true;
+    }
+    return false;
+}
 /** `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
@@ -4782,8 +4958,12 @@ export function lowerClassExpressionInfo(lowerer, expr) {
  * 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) {
+ * the member fences don't apply.
+ *
+ * `binding` is the local of a function-local class declaration's name,
+ * declared without a value; the class value assigns it before the class's
+ * static members are defined (see initializeRuntimeStatics). */
+export function lowerClassExpression(lowerer, expr, binding) {
     if (decoratorNodesOf(expr).length > 0 ||
         expr.members.nodes.some((m) => decoratorNodesOf(m).length > 0)) {
         if (!isJsSourceFile(ts.getSourceFileOfNode(expr)) && expr.typeParameters === undefined) {
@@ -4797,6 +4977,28 @@ export function lowerClassExpression(lowerer, expr) {
         }
     }
     const info = lowerClassExpressionInfo(lowerer, expr);
+    // A function-local class expression's own name is a binding of its body:
+    // declared before the members lower, so their references to the name
+    // resolve to it. The class value captures it before it is assigned, as
+    // it captures a class declaration's binding.
+    if (!binding &&
+        info.localClass &&
+        ts.isClassExpression(expr) &&
+        expr.name &&
+        classExpressionNamesItself(lowerer, expr)) {
+        const own = lowerer.declareLocal(expr.name, expr.name.text, { kind: "classval", className: info.def.name }, true);
+        const value = lowerClassValue(lowerer, expr, info, own);
+        return {
+            kind: "seqExpr",
+            stmts: [{ kind: "varDecl", localId: own.id, init: null, loc: value.loc }],
+            result: value,
+            type: value.type,
+            loc: value.loc,
+        };
+    }
+    return lowerClassValue(lowerer, expr, info, binding);
+}
+function lowerClassValue(lowerer, expr, info, binding) {
     if (!info.localClass &&
         !info.expressionInitializationEmitted &&
         (info.callableBase ||
@@ -4843,7 +5045,7 @@ 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, {
+        const built = {
             kind: "seqExpr",
             stmts: [
                 { kind: "varDecl", localId: baseLocal.id, init: base, loc },
@@ -4876,7 +5078,8 @@ export function lowerClassExpression(lowerer, expr) {
             result: clsRef,
             type: value.type,
             loc,
-        });
+        };
+        return initializeRuntimeStatics(lowerer, info, built, binding);
     }
     if (info.localClass?.baseExpression && info.base && value.kind === "classRef") {
         const loc = locOf(expr);
@@ -4891,7 +5094,7 @@ 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, {
+        const built = {
             kind: "seqExpr",
             stmts: [
                 { kind: "varDecl", localId: baseLocal.id, init: base, loc },
@@ -4930,11 +5133,52 @@ export function lowerClassExpression(lowerer, expr) {
             result: clsRef,
             type: value.type,
             loc,
-        });
+        };
+        return initializeRuntimeStatics(lowerer, info, built, binding);
     }
-    return info.localClass
-        ? initializeRuntimeStatics(lowerer, info, value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value)
-        : value;
+    if (!info.localClass)
+        return value;
+    const classValue = initializeRuntimeStatics(lowerer, info, value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value, binding);
+    // The base resolves statically here, but Node still evaluates the
+    // heritage expression each time the class definition runs, first.
+    const heritage = heritageWithEffects(expr);
+    if (heritage === undefined)
+        return classValue;
+    return {
+        kind: "seqExpr",
+        stmts: [lowerer.lowerExprStatement(heritage)],
+        result: classValue,
+        type: classValue.type,
+        loc: classValue.loc,
+    };
+}
+/** The `extends` expression of `decl` when evaluating it can have effects
+ * (a call, construction, assignment, update, delete, await or yield
+ * outside nested functions). */
+function heritageWithEffects(decl) {
+    const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
+    if (heritage === undefined)
+        return undefined;
+    const effects = (node) => {
+        if (ts.isFunctionLike(node) || ts.isClassDeclaration(node) || ts.isClassExpression(node))
+            return false;
+        if (ts.isCallExpression(node) ||
+            ts.isNewExpression(node) ||
+            ts.isTaggedTemplateExpression(node) ||
+            ts.isDeleteExpression(node) ||
+            ts.isAwaitExpression(node) ||
+            ts.isYieldExpression(node) ||
+            (ts.isPrefixUnaryExpression(node) &&
+                (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                    node.operator === ts.SyntaxKind.MinusMinusToken)) ||
+            ts.isPostfixUnaryExpression(node) ||
+            (ts.isBinaryExpression(node) &&
+                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment))
+            return true;
+        return ts.forEachChild(node, (child) => effects(child) || undefined) ?? false;
+    };
+    return effects(heritage) ? heritage : undefined;
 }
 /** The EXACT class a receiver expression is statically known to BE (not
  * merely be typed by): the class name itself, or a `const` binding
@@ -5195,6 +5439,13 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
     const runtimeStatic = directRuntimeStaticCall(lowerer, call, access, info, throughValue);
     if (runtimeStatic)
         return runtimeStatic;
+    // Date's statics through a class declared `extends Date`
+    // (`Moment.UTC(...)`), which inherits them.
+    if (dateRootOf(info) && !findStaticOn(lowerer, info, access.name.text)) {
+        const date = lowerDateStaticCall(lowerer, call, access.name.text);
+        if (date)
+            return date;
+    }
     if ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, access.name.text)?.field) ||
         (info.callableBase &&
             !findStaticOn(lowerer, info, access.name.text) &&
@@ -5229,7 +5480,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         // through-a-VALUE shadowing fence as plain statics.
         const gfound = findGenericStaticOn(lowerer, info, access.name.text);
         if (!gfound)
-            return null;
+            return classConstructorCall(lowerer, call, access, info);
         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)`);
         }
@@ -5298,6 +5549,74 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
     const args = lowerer.completeArgs(call.arguments.nodes, found.method.params, loc, call);
     return { kind: "call", callee: fnName, args, type: found.method.ret, loc };
 }
+/** `C.call(thisArg, ...)` / `C.apply(thisArg, args)` on a program class that
+ * declares no such static: Function.prototype.call/apply invoke the class
+ * constructor without `new`, which throws Node's TypeError "Class
+ * constructor C cannot be invoked without 'new'" after the arguments are
+ * evaluated (and, for apply, after the argument list is read). The boxed
+ * class value's call path throws exactly that. Neither expando statics nor
+ * writes through untyped values can give a class an own `call` or `apply`.
+ * A receiver that may hold a subclass at run time (a class value, `this` in
+ * a static method) needs every subclass to lack such a static too. The
+ * receiver must be one the caller does not evaluate again (a name, `this`,
+ * or a namespace member). Null otherwise. */
+function classConstructorCall(lowerer, call, access, info) {
+    const name = access.name.text;
+    const receiver = access.expression;
+    if ((name !== "call" && name !== "apply") ||
+        !info.decl ||
+        info.def.runtime ||
+        info.builtinError ||
+        info.builtinEmitter ||
+        info.builtinStream ||
+        info.builtinEventTarget ||
+        info.runtimeStatics?.length ||
+        declaresStaticAbove(info, name) ||
+        (exactClassOfReceiver(lowerer, receiver) !== info &&
+            info.subclasses.some((subclass) => declaresStaticBelow(subclass, name))) ||
+        call.arguments.nodes.some(ts.isSpreadElement) ||
+        !(ts.isIdentifier(receiver) ||
+            receiver.kind === ts.SyntaxKind.ThisKeyword ||
+            (ts.isPropertyAccessExpression(receiver) && nsMemberIdentOf(lowerer, receiver) !== null)))
+        return null;
+    return {
+        kind: "dynInvoke",
+        recv: lowerer.lowerExprExpecting(receiver, DYN),
+        method: name,
+        calleeName: ts.getTextOfNode(access),
+        args: call.arguments.nodes.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
+        type: DYN,
+        loc: locOf(call),
+    };
+}
+/** Whether `info`'s declaration has a static member that may be named `name`
+ * (a method, field or accessor of that name, or a computed name), or `info`
+ * has no declaration to tell. */
+function declaresStatic(info, name) {
+    if (!info.decl)
+        return true;
+    return info.decl.members.nodes.some((member) => member.name !== undefined &&
+        ts.canHaveModifiers(member) &&
+        ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ===
+            true &&
+        (ts.isComputedPropertyName(member.name) ||
+            ((ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) &&
+                member.name.text === name)));
+}
+/** declaresStatic over `info` and its bases, which it inherits statics from. */
+function declaresStaticAbove(info, name) {
+    for (let c = info; c; c = c.base)
+        if (declaresStatic(c, name))
+            return true;
+    return false;
+}
+/** declaresStatic over `info` and its subclasses, or runtime statics, which a
+ * function-local JavaScript class defines at run time. */
+function declaresStaticBelow(info, name) {
+    return (declaresStatic(info, name) ||
+        !!info.runtimeStatics?.length ||
+        info.subclasses.some((subclass) => declaresStaticBelow(subclass, name)));
+}
 /** `C.m(...)` where `m` is a static method that a function-local
  * JavaScript class defines at runtime (a factory's `class extends base`),
  * inherited by `C` through its statically known base chain. When the body
@@ -5685,11 +6004,94 @@ export function inHierarchy(lowerer, info) {
  * 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) {
+    if (info.decl !== null && localOverrideBelow(lowerer, info.decl, name))
+        return true;
     return info.subclasses.some((s) => {
         const m = s.methods.get(name);
         return (m !== undefined && m.abstract !== true) || lowerer.overrideBelow(s, name);
     });
 }
+/** The class node an `extends` clause names: a class declaration, or the
+ * class expression a variable is initialized with. */
+function extendedClassNode(lowerer, decl) {
+    const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
+    if (!heritage || !ts.isIdentifier(heritage))
+        return null;
+    let symbol = lowerer.checker.getSymbolAtLocation(heritage);
+    if (symbol && symbol.flags & ts.SymbolFlags.Alias)
+        symbol = lowerer.checker.getAliasedSymbol(symbol);
+    const target = symbol?.valueDeclaration;
+    if (!target)
+        return null;
+    if (ts.isClassDeclaration(target) || ts.isClassExpression(target))
+        return target;
+    if (ts.isVariableDeclaration(target) && target.initializer) {
+        let init = target.initializer;
+        while (ts.isParenthesizedExpression(init))
+            init = init.expression;
+        if (ts.isClassExpression(init))
+            return init;
+    }
+    return null;
+}
+/** The function-local classes that extend the class node `base`. Function
+ * bodies lower on demand, after code that may already call methods of a
+ * class their local classes extend, so such a subclass is not yet in its
+ * base's `subclasses` when those calls lower. */
+function localSubclassesOf(lowerer, base) {
+    let index = lowerer.localSubclassIndex;
+    if (index === null) {
+        index = new Map();
+        const files = lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry];
+        for (const sf of files) {
+            if (!sf.text.includes("extends"))
+                continue;
+            ts.walkPreorder(sf, (node) => {
+                if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) &&
+                    node.heritageClauses !== undefined &&
+                    functionLocalClass(node)) {
+                    const extended = extendedClassNode(lowerer, node);
+                    if (extended) {
+                        const list = index.get(extended);
+                        if (list)
+                            list.push(node);
+                        else
+                            index.set(extended, [node]);
+                    }
+                }
+                return undefined;
+            });
+        }
+        lowerer.localSubclassIndex = index;
+    }
+    return index.get(base) ?? [];
+}
+/** True when a function-local class below the class node `base` declares
+ * a concrete instance method or accessor `name` (accessors are keyed
+ * `get:x` and `set:x`). A call on `base`'s class then dispatches on the
+ * receiver; devirtualization turns it back into a direct call when no such
+ * override is reachable. */
+function localOverrideBelow(lowerer, base, name, visited) {
+    const subclasses = localSubclassesOf(lowerer, base);
+    if (subclasses.length === 0)
+        return false;
+    visited ??= new Set();
+    if (visited.has(base))
+        return false;
+    visited.add(base);
+    const accessor = name.startsWith("get:") ? "get" : name.startsWith("set:") ? "set" : null;
+    const member = accessor ? name.slice(4) : name;
+    return subclasses.some((sub) => sub.members.nodes.some((m) => (accessor === null
+        ? ts.isMethodDeclaration(m)
+        : accessor === "get"
+            ? ts.isGetAccessorDeclaration(m)
+            : ts.isSetAccessorDeclaration(m)) &&
+        m.body !== undefined &&
+        m.name !== undefined &&
+        (ts.isIdentifier(m.name) || ts.isStringLiteral(m.name)) &&
+        m.name.text === member &&
+        !ts.getModifiers(m)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword)) || localOverrideBelow(lowerer, sub, name, visited));
+}
 /** The nearest GENERIC-method declaration of `name` at/above `info` —
  * findMethodOn's twin over the genericMethods tables. */
 export function findGenericMethodOn(lowerer, info, name) {
@@ -6288,7 +6690,7 @@ function lowerClassCtorInner(lowerer, info) {
                 lowerer.ctx.argumentsLocal = local;
             }
             body.push(...declared.prologue);
-            if (!ctorBase && !info.callableBase) {
+            if (!ctorBase && !info.callableBase && !info.extendsDate) {
                 // Node's base-class order: field initializers run at the start
                 // of construction, the parameter-property assignments open the
                 // constructor body (probed — a field initializer reading a
@@ -6303,7 +6705,7 @@ function lowerClassCtorInner(lowerer, info) {
             }
         }
         else {
-            if (ctorBase || info.callableBase) {
+            if (ctorBase || info.callableBase || info.extendsDate) {
                 // Synthetic forwarding params (the inherited ABI signature).
                 // Nothing references them by symbol — only the super call below,
                 // which forwards the already-completed values UNCHANGED (defaults
@@ -6486,7 +6888,7 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
     const key = `${cit.className}:${typeKey(outElem)}`;
     let name = lowerer.iterDrainHelpers.get(key);
     if (!name) {
-        name = `%iter.drain.${lowerer.iterDrainHelpers.size}`;
+        name = keyedHelperName(lowerer, "%iter.drain", key);
         lowerer.iterDrainHelpers.set(key, name);
         const recvT = { kind: "object", className: cit.className };
         const recvRef = { kind: "varRef", localId: "r.0", type: recvT, loc };
@@ -6594,7 +6996,7 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
     const key = `it:${cit.iterT.className}`;
     let name = lowerer.iterDrainHelpers.get(key);
     if (!name) {
-        name = `%iter.drain.${lowerer.iterDrainHelpers.size}`;
+        name = keyedHelperName(lowerer, "%iter.drain", key);
         lowerer.iterDrainHelpers.set(key, name);
         const itRef = { kind: "varRef", localId: "it.0", type: cit.iterT, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: outT, loc };
@@ -7089,12 +7491,39 @@ function superCallInStatementPosition(call) {
         const parent = node.parent;
         if (ts.isExpressionStatement(parent))
             return true;
+        if (ts.isIfStatement(parent)) {
+            const lead = superConditionLead(parent.expression);
+            return lead !== null && call.pos >= lead.left.pos && call.end <= lead.left.end;
+        }
         const comma = ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.CommaToken;
         if (!comma && !ts.isParenthesizedExpression(parent))
             return false;
         node = parent;
     }
 }
+/** The comma chain of an `if` condition whose leading operands hold a
+ * super() call (`if (super(), r === 0) throw ...`, as minifiers join a
+ * super statement with the next test), or null. The if statement runs the
+ * chain's left operand as a statement first and tests its right operand,
+ * which is what the comma evaluates. */
+export function superConditionLead(cond) {
+    let expr = cond;
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (!ts.isBinaryExpression(expr) || expr.operatorToken.kind !== ts.SyntaxKind.CommaToken)
+        return null;
+    const holdsSuperCall = (operand) => {
+        let e = operand;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (ts.isCallExpression(e))
+            return e.expression.kind === ts.SyntaxKind.SuperKeyword;
+        return (ts.isBinaryExpression(e) &&
+            e.operatorToken.kind === ts.SyntaxKind.CommaToken &&
+            (holdsSuperCall(e.left) || holdsSuperCall(e.right)));
+    };
+    return holdsSuperCall(expr.left) ? expr : null;
+}
 /** 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. */
@@ -7126,9 +7555,11 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
                 loc,
             },
         ];
-        if (info.callableBase) {
+        if (info.callableBase || info.extendsDate) {
             if (superCall.arguments.nodes.some(ts.isSpreadElement))
-                lowerer.unsupported("SC1090", superCall, "spreading explicit super arguments into an ordinary constructor");
+                lowerer.unsupported("SC1090", superCall, info.extendsDate
+                    ? "spreading super arguments into the Date constructor"
+                    : "spreading explicit super arguments into an ordinary constructor");
             const pack = {
                 kind: "dynArrLit",
                 elems: superCall.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
@@ -7271,6 +7702,8 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         type: { kind: "object", className: info.def.name },
         loc,
     };
+    if (info.extendsDate)
+        return dateSuperCall(thisRef, info, args[0], loc);
     if (info.callableBase)
         return {
             kind: "exprStmt",
@@ -7351,8 +7784,10 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         // The SYNTHESIZED constructor of a ctor-less stream subclass:
         // super() with default options (underscore methods still bind; a
         // construction passing options requires a declared constructor —
-        // lowerNew fences that). Zero options ⇒ exactly one init stmt.
-        return lowerStreamSuperCall(lowerer, info, base, [], thisLocal, loc, info.decl ?? info.ctor)[0];
+        // lowerNew fences that). Zero options ⇒ the init stmt, then the
+        // class's _writev/_construct follow-ups.
+        const stmts = lowerStreamSuperCall(lowerer, info, base, [], thisLocal, loc, info.decl ?? info.ctor);
+        return stmts.length === 1 ? stmts[0] : { kind: "block", body: stmts, loc };
     }
     lowerer.noteSuperConstructorEdge(`%${base.def.name}.constructor`);
     const call = {
@@ -7373,6 +7808,22 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
  * super dispatch is static in JS too, never through the dynamic class. */
 export function lowerSuperMethodCall(lowerer, call, access) {
     const cls = lowerer.currentClass;
+    // `super.toISOString()` in a class declared `extends Date`.
+    if (cls?.extendsDate && !cls.base) {
+        const thisL = lowerer.resolveThis();
+        if (!thisL)
+            lowerer.unsupported("SC1080", access);
+        const thisRef = {
+            kind: "varRef",
+            localId: thisL.id,
+            type: thisL.type,
+            loc: locOf(call),
+        };
+        const date = lowerDateSuperMethodCall(lowerer, call, access.name.text, cls, thisRef);
+        if (date)
+            return date;
+        lowerer.unsupported("SC1090", access, `'super.${access.name.text}' (Date.prototype does not declare it)`);
+    }
     if (!cls?.base) {
         // tsc rejects super outside derived-class bodies first; defensive.
         lowerer.unsupported("SC1090", access, "'super' outside a derived class");
@@ -7420,6 +7871,18 @@ export function lowerSuperMethodCall(lowerer, call, access) {
         // `super.dispatchEvent(e)`, `super.preventDefault()`: the inherited
         // runtime members over this method's own `this` (subclasses cannot
         // override them, so the static answer is the runtime's).
+        if (dateRootOf(cls.base) && isDatePrototypeMethod(access.name.text)) {
+            const thisL = lowerer.resolveThis();
+            if (!thisL)
+                lowerer.unsupported("SC1080", access);
+            const thisRef = {
+                kind: "varRef",
+                localId: thisL.id,
+                type: thisL.type,
+                loc: locOf(call),
+            };
+            return lowerDateSuperMethodCall(lowerer, call, access.name.text, cls.base, thisRef);
+        }
         if (eventTargetApiMethod(cls.base, access.name.text)) {
             const thisL = lowerer.resolveThis();
             if (!thisL)
@@ -8057,6 +8520,13 @@ export function lowerNew(lowerer, expr) {
         if (httpServer)
             return httpServer;
     }
+    // `new tls.TLSSocket(socket, options)` — the server-mode wrap of an open
+    // socket (lower-server).
+    {
+        const tlsSocket = lowerTlsSocketNew(lowerer, expr);
+        if (tlsSocket)
+            return tlsSocket;
+    }
     // `new http.Agent(opts?)` / `new https.Agent(opts?)` — the Agent
     // handle (lower-server): getName/destroy/counters through the dyn
     // handle ops, requests thread it via the agent option.
@@ -8555,6 +9025,40 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
+        // A FinalizationRegistry construction: register and unregister keep
+        // their bookkeeping, and the cleanup callback never runs, which
+        // ECMAScript allows (scr_finalization_registry_new).
+        if (symbol !== null &&
+            ts.symbolName(symbol) === "FinalizationRegistry" &&
+            lowerer.isStdlibSymbol(symbol)) {
+            const args = expr.arguments?.nodes ?? [];
+            if (args.some(ts.isSpreadElement)) {
+                lowerer.unsupported("SC1090", expr, "FinalizationRegistry construction with spread arguments");
+            }
+            const cleanup = args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc);
+            const surplus = args.slice(1).map((arg) => lowerer.lowerExpr(arg));
+            const created = {
+                kind: "libCall",
+                fn: "finalizationRegistry.new",
+                args: [cleanup],
+                type: DYN,
+                loc,
+            };
+            if (surplus.length === 0)
+                return created;
+            // Surplus arguments evaluate after the cleanup argument and are ignored.
+            const local = lowerer.declareHiddenLocal("%finalizationCleanup", DYN);
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "varDecl", localId: local.id, init: cleanup, loc },
+                    ...surplus.map((value) => ({ kind: "exprStmt", expr: value, loc })),
+                ],
+                result: { ...created, args: [varRef(local.id, DYN, loc)] },
+                type: DYN,
+                loc,
+            };
+        }
         // `new Set<T>()`: construct + bulk add from supported values,
         // including live collection cursors. Duplicates collapse in insertion order.
         if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Set")) {
@@ -8735,7 +9239,6 @@ export function lowerNew(lowerer, expr) {
                 Number: "boxed wrapper objects have no lowering — use the number primitive",
                 Boolean: "boxed wrapper objects have no lowering — use the boolean primitive",
                 WeakRef: "deref()-after-collect exposes GC timing — genuinely dynamic; hold a strong reference instead",
-                FinalizationRegistry: "finalization callbacks expose GC timing — genuinely dynamic; release resources explicitly instead",
                 SharedArrayBuffer: "no shared-memory threads exist in a compiled program — Uint8Array is the byte storage",
                 ArrayBuffer: "native ArrayBuffer construction supports fixed-length storage; resizable buffers remain unsupported",
                 Proxy: "native Proxy construction requires checked-native plain targets and handlers",
@@ -8782,7 +9285,7 @@ export function lowerNew(lowerer, expr) {
             const key = `x509.record:${isBytes ? "bytes" : "str"}`;
             let helper = lowerer.valueHelpers.get(key);
             if (!helper) {
-                helper = `%x509.record.${lowerer.valueHelpers.size}`;
+                helper = keyedHelperName(lowerer, "%x509.record", key);
                 lowerer.valueHelpers.set(key, helper);
                 const dataT = data.type;
                 const dRef = { kind: "varRef", localId: "d.0", type: dataT, loc };
@@ -9024,4 +9527,36 @@ function genericFieldFnNodeOf(member) {
     }
     return null;
 }
+/** Whether a JavaScript class's own binding is the target of
+ * `Object.defineProperty`/`defineProperties` in its file
+ * (`Object.defineProperty(Definition, "name", { value })`): its constructor
+ * then needs a live own-property table. */
+function definedThroughReflection(lowerer, decl) {
+    const name = decl.name;
+    const sf = ts.getSourceFileOfNode(decl);
+    if (name === undefined || !sf.text.includes("definePropert"))
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(name);
+    if (symbol === undefined)
+        return false;
+    let found = false;
+    ts.walkPreorder(sf, (node) => {
+        if (found)
+            return "stop";
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            (node.expression.name.text === "defineProperty" ||
+                node.expression.name.text === "defineProperties") &&
+            lowerer.stdlibGlobalMember(node.expression, "Object") !== null) {
+            const target = node.arguments.nodes[0];
+            if (target !== undefined &&
+                ts.isIdentifier(target) &&
+                target.text === name.text &&
+                lowerer.checker.getSymbolAtLocation(target) === symbol)
+                found = true;
+        }
+        return undefined;
+    });
+    return found;
+}
 //# sourceMappingURL=lower-classes.js.map