@scriptc/compiler 0.4.3 → 0.4.5

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

@@ -1,14 +1,15 @@
+import { lowerAsyncLocalStorageOptions } from "./builtins/async-context.js";
 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";
+import { dynUndefinedExpr, nodeThrowExpr, strLit, varRef } from "../../ir/build.js";
 import { constructedFromValue, constructedValue, superIntoResultSlot, } from "./constructor-returns.js";
 import { checkedIterableSpread } from "./checked-iterable-spread.js";
-import { lowerReadlineUiNew } from "./builtins/readline.js";
-import { builtinMemberRequireDecl } from "./builtins/module-bindings.js";
+import { lowerReadlineInterfaceNew, lowerReadlineUiNew } from "./builtins/readline.js";
+import { builtinMemberBindingTarget, builtinMemberRequireDecl, } from "./builtins/module-bindings.js";
 import { checkedClassUnionAssertion } from "./class-assertions.js";
 import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -25,7 +26,7 @@ import { lowerZlibStreamNew, zlibClassName, zlibStreamModeOf } from "./builtins/
 import { everyStmtList } from "../../ir/traverse.js";
 import { builtinClassAliasOf, builtinClassRefOf, } from "./builtins/class-values.js";
 import { inlineNamespaceRequireOf, lowerWithInlineRequireInit } from "./cjs-inline-require.js";
-import { BOOL, canDynCheckTo, DATE_T, DYN, F64, bytesOf, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, classValueConstructor, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
+import { BOOL, BYTES_U8, canDynCheckTo, DATE_T, DYN, F64, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, classValueConstructor, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
 import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, genericLocalClassResult, } from "./generic-functions.js";
 import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
 import { appendImplicitUndefinedReturn, hasExplicitJsDocReturn } from "./function-returns.js";
@@ -33,20 +34,20 @@ 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 { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
+import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, X509_DER_FIELD, X509_PUBLIC_KEY_FIELD, } 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";
 import { isCjsRequireGlobal } from "./lower-node-module.js";
 import { lowerArrayConstructor } from "./containers/array-construction.js";
+import { initializedCollectionType } from "./js-collection-types.js";
 import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
 import { lowerObjectConstructor } from "./containers/indexed-objects.js";
-import { knownBufEncoding, lowerNodeModulesBufferConstruct } from "./containers/bytes.js";
-import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { knownBufEncoding, lowerBufferConstruct } from "./containers/bytes.js";
 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 { noLoweringDiag, unsupportedPackageValueDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.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";
@@ -63,11 +64,11 @@ import { accessorInterceptsBase, accessorNames, construction, constructionPrefix
 import { lowerObjectFactoryNew } from "./object-factory-new.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.js";
-import { classPrototypeData } from "./class-prototypes.js";
+import { classPrototypeData, reflectClassPrototype } from "./class-prototypes.js";
 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 { reflectedClassMethodValue, reflectedClassStaticMethodValue, } from "./class-method-values.js";
 import { identifierReadSymbol } from "./surfaces.js";
 export function returnsOnlyThis(member) {
     const body = member.body;
@@ -891,7 +892,7 @@ 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 === "generator") {
+        if (a.kind === "map" || a.kind === "regex" || a.kind === "generator") {
             return null;
         }
         byKey.set(typeKey(a), a);
@@ -3042,7 +3043,6 @@ mixin) {
                     declared.kind !== "union" &&
                     declared.kind !== "dyn" &&
                     declared.kind !== "map" &&
-                    declared.kind !== "date" &&
                     declared.kind !== "generator" &&
                     declared.kind !== "void" &&
                     declared.kind !== "caught";
@@ -3432,6 +3432,11 @@ mixin) {
                 // INSTANTIATION prints its family's name — JS has one `Box`.
                 jsName: jsNameOverride ?? decl.name?.text ?? "",
                 ...(base ? { base: base.def.name } : {}),
+                ...(decl.members.nodes.some((member) => ts.isPropertyDeclaration(member) &&
+                    !ts.isPrivateIdentifier(member.name) &&
+                    member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.StaticKeyword))
+                    ? { ownStaticFields: true }
+                    : {}),
                 jsLength: ctor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) === -1
                     ? ctor.parameters.nodes.length
                     : Math.max(0, ctor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) ?? 0),
@@ -4601,20 +4606,27 @@ export function lowerStaticFieldRead(lowerer, expr) {
         return null;
     if (expr.questionDotToken)
         return null;
-    if (!ts.isIdentifier(expr.expression) &&
-        expr.expression.kind !== ts.SyntaxKind.ThisKeyword &&
-        exactClassOfReceiver(lowerer, expr.expression) === null)
+    const info = staticReceiverClass(lowerer, expr.expression);
+    if (!info)
         return null;
-    const symbol = ts.isIdentifier(expr.expression)
-        ? lowerer.resolveValueSymbol(expr.expression)
-        : null;
+    return lowerClassStaticRead(lowerer, info, expr.name.text, expr.expression, expr);
+}
+/** The class a static member read through `receiver` reads exactly: the
+ * class a name binds (directly, through a require binding, or through a
+ * const alias), or null. */
+export function staticReceiverClass(lowerer, receiver) {
+    if (!ts.isIdentifier(receiver) &&
+        receiver.kind !== ts.SyntaxKind.ThisKeyword &&
+        exactClassOfReceiver(lowerer, receiver) === null)
+        return null;
+    const symbol = ts.isIdentifier(receiver) ? lowerer.resolveValueSymbol(receiver) : null;
     const info = (symbol ? lowerer.classBySymbol.get(symbol) : undefined) ??
         // A require binding over `module.exports = class {…}` (the alias
         // lands on the expression's own symbol): resolve/collect on demand,
         // or `C.name` below would fall through to paths that answer for
         // stdlib globals instead of this class.
         propertyAssignedClassInfoOf(lowerer, symbol) ??
-        exactClassOfReceiver(lowerer, expr.expression) ??
+        exactClassOfReceiver(lowerer, receiver) ??
         undefined;
     if (!info)
         return null;
@@ -4625,20 +4637,27 @@ export function lowerStaticFieldRead(lowerer, expr) {
     // runtime value.
     if (info.classDecorators?.valueGlobalId !== undefined)
         return null;
-    const loc = locOf(expr);
-    const found = findStaticOn(lowerer, info, expr.name.text);
+    return info;
+}
+/** The static member `name` of `info` read through `receiver` (an exact
+ * reference to the class, see staticReceiverClass): `C.name` for the
+ * property access `site`, or a destructuring element over `C` whose
+ * initializer is `site`. Null when the class has no such member. */
+export function lowerClassStaticRead(lowerer, info, name, receiver, site) {
+    const loc = locOf(site);
+    const found = findStaticOn(lowerer, info, name);
     // 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);
+        ["now", "parse", "UTC"].includes(name) &&
+        !(ts.isCallExpression(site.parent) && site.parent.expression === site))
+        lowerer.noLowering(`Date.${name} read through a class that extends Date`, site);
     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 },
+            value: lowerer.coerceToExpected(classValueRef(lowerer, info, receiver), DYN),
+            key: { kind: "strLit", value: name, type: STRING, loc },
             type: DYN,
             loc,
         };
@@ -4646,8 +4665,8 @@ export function lowerStaticFieldRead(lowerer, expr) {
     // name: in JS the brand lives on that one constructor object, so
     // `D.#s` (a subclass receiver) throws Node's TypeError instead of
     // reaching up the chain — reported as SC1090 instead of resolved.
-    if (found && expr.name.text.startsWith("#") && found.declarer !== info) {
-        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 && name.startsWith("#") && found.declarer !== info) {
+        lowerer.unsupported("SC1090", site, `reading the private static '${name}' 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) {
         const value = {
@@ -4656,30 +4675,32 @@ export function lowerStaticFieldRead(lowerer, expr) {
             type: found.field.type,
             loc,
         };
-        return found.field.runtimeOptional ? value : lowerer.maybeNarrow(value, expr);
+        return found.field.runtimeOptional || !ts.isPropertyAccessExpression(site)
+            ? value
+            : lowerer.maybeNarrow(value, site);
     }
     if (found) {
-        return staticMethodValue(lowerer, found.declarer, expr.name.text, found.method, expr, loc);
+        return staticMethodValue(lowerer, found.declarer, name, found.method, site, loc);
     }
     // A GENERIC static method as a VALUE: the pinned-value rule verbatim
     // (lowerGenericFnValue) — a slot spelling one concrete signature names
     // an instance, an unpinned reference fences by name.
     {
-        const gfound = findGenericStaticOn(lowerer, info, expr.name.text);
+        const gfound = findGenericStaticOn(lowerer, info, name);
         if (gfound)
-            return lowerer.lowerGenericFnValue(expr, gfound.info);
+            return lowerer.lowerGenericFnValue(site, gfound.info);
     }
     // `C.name` — the JS-observable class name, a compile-time constant on
     // the direct spelling (tsc rejects user statics named `name`, so the
     // chain above can never shadow it in TypeScript sources). A class of an
     // import cycle reads it from its class object instead, whose reference
     // checks the class's initialization (checkCycleBindingAccesses).
-    if (expr.name.text === "name" && info.def.jsName !== undefined) {
+    if (name === "name" && info.def.jsName !== undefined) {
         if (lowerer.classInitFlags.get(info.def.name)?.cycle === true)
             return {
                 kind: "libCall",
                 fn: "class.name",
-                args: [classValueRef(lowerer, info, expr.expression)],
+                args: [classValueRef(lowerer, info, receiver)],
                 type: STRING,
                 loc,
             };
@@ -4688,26 +4709,26 @@ export function lowerStaticFieldRead(lowerer, expr) {
     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 },
+            value: lowerer.coerceToExpected(classValueRef(lowerer, info, receiver), DYN),
+            key: { kind: "strLit", value: name, type: STRING, loc },
             type: DYN,
             loc,
         };
-    const data = classStaticDataFor(lowerer, info, expr.name.text, loc);
+    const data = classStaticDataFor(lowerer, info, name, loc);
     if (data) {
         const value = {
             kind: "dynKeyGet",
             value: data,
-            key: { kind: "strLit", value: expr.name.text, type: STRING, loc },
+            key: { kind: "strLit", value: name, 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(ts.getSourceFileOfNode(expr))
+        const type = isJsSourceFile(ts.getSourceFileOfNode(site))
             ? null
-            : lowerer.mapTypeOf(lowerer.typeOf(expr));
+            : lowerer.mapTypeOf(lowerer.typeOf(site));
         return type ? lowerer.coerceToExpected(value, type) : value;
     }
     return null;
@@ -5454,7 +5475,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
             kind: "dynInvoke",
             recv: lowerer.lowerExprExpecting(access.expression, DYN),
             method: access.name.text,
-            calleeName: access.name.text,
+            calleeName: ts.getTextOfNode(access),
             args: call.arguments.nodes.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
             type: DYN,
             loc,
@@ -5757,8 +5778,8 @@ function capturesEnclosingScope(lowerer, member, classDecl) {
  * reflection: the member a runtime lookup finds can then differ. */
 function memberAssigned(lowerer, member, name) {
     let found = false;
-    for (const sf of lowerer.program.getSourceFiles()) {
-        if (sf.isDeclarationFile || found)
+    for (const sf of lowerer.program.getImplementationSourceFiles()) {
+        if (found)
             continue;
         if (!sf.text.includes(name))
             continue;
@@ -6808,14 +6829,23 @@ export function classMemberNameOf(lowerer, name) {
             member === "asyncIterator" ||
             member === "dispose" ||
             member === "asyncDispose" ||
-            member === "toPrimitive") {
+            member === "toPrimitive" ||
+            // A toStringTag field keeps its symbol field name; its accessor and
+            // method forms take the method slot name.
+            (member === "toStringTag" && !ts.isPropertyDeclaration(name.parent))) {
             return `sym:${member}`;
         }
     }
     return (classSymbolKeyOf(lowerer, name.expression)?.fieldName ??
         lowerer.foldedStringKeyOf(name.expression));
 }
-export function classIteratorOf(lowerer, t) {
+/** A return() result type that is always an object: IteratorClose after a
+ * break throws a TypeError for any other result, which these desugars do
+ * not model. */
+function objectResult(t) {
+    return t.kind === "record" || t.kind === "object";
+}
+export function classIteratorOf(lowerer, t, options = {}) {
     if (t.kind !== "object")
         return null;
     const info = lowerer.classes.get(t.className);
@@ -6825,19 +6855,48 @@ export function classIteratorOf(lowerer, t) {
     if (!iter || iter.sig.params.length !== 0 || iter.sig.abstract === true)
         return null;
     const iterT = iter.sig.ret;
-    if (iterT.kind !== "object")
-        return null;
-    const itInfo = lowerer.classes.get(iterT.className);
-    if (!itInfo)
-        return null;
-    // IteratorClose honesty: a declared return()/throw() would be called
-    // by JS on abrupt completion; these desugars never close.
-    if (findMethodOn(lowerer, itInfo, "return") || findMethodOn(lowerer, itInfo, "throw"))
-        return null;
-    const next = findMethodOn(lowerer, itInfo, "next");
-    if (!next || next.sig.params.length !== 0 || next.sig.abstract === true)
+    let resultT;
+    let hasReturn;
+    if (iterT.kind === "object") {
+        const itInfo = lowerer.classes.get(iterT.className);
+        if (!itInfo)
+            return null;
+        // IteratorClose honesty: a declared return() would be called by JS on
+        // abrupt completion, so only a consumer that closes takes it; for-of
+        // never calls throw(), the other consumers refuse it.
+        const close = findMethodOn(lowerer, itInfo, "return");
+        if (close &&
+            (!options.close ||
+                close.sig.abstract === true ||
+                close.sig.params.length !== 0 ||
+                !objectResult(close.sig.ret)))
+            return null;
+        if (findMethodOn(lowerer, itInfo, "throw") && !options.close)
+            return null;
+        const next = findMethodOn(lowerer, itInfo, "next");
+        if (!next || next.sig.params.length !== 0 || next.sig.abstract === true)
+            return null;
+        resultT = next.sig.ret;
+        hasReturn = !!close;
+    }
+    else if (iterT.kind === "record" && options.records) {
+        const fields = lowerer.shapes.get(iterT.shapeId)?.fields;
+        const next = fields?.find((f) => f.name === "next")?.type;
+        if (!next || next.kind !== "func" || next.params.length !== 0 || next.rest)
+            return null;
+        const close = fields?.find((f) => f.name === "return")?.type;
+        if (close &&
+            (!options.close ||
+                close.kind !== "func" ||
+                close.params.length !== 0 ||
+                close.rest ||
+                !objectResult(close.ret)))
+            return null;
+        resultT = next.ret;
+        hasReturn = close !== undefined;
+    }
+    else
         return null;
-    const resultT = next.sig.ret;
     if (resultT.kind !== "record")
         return null;
     const shape = lowerer.shapes.get(resultT.shapeId);
@@ -6853,12 +6912,62 @@ export function classIteratorOf(lowerer, t) {
         resultT,
         valueT: value.type,
         hasDone: done !== undefined,
+        hasReturn,
     };
 }
-/** The `it.next()` step of a class iterator as an ordinary (possibly
- * virtual) method call. */
-export function classIteratorNextCall(lowerer, cit, itRef, loc) {
-    return accessorCall(lowerer, cit.iterT.className, "next", itRef, [], cit.resultT, loc);
+/** The `next` an object-literal iterator's protocol calls, read once when
+ * the iterator opens: JS keeps the `next` it reads then in the iterator
+ * record, so a `next` the iterator assigns while it runs is not called.
+ * Null for an iterator class, whose `next` is a method. */
+export function classIteratorNextRead(lowerer, cit, itRef, loc) {
+    const iterT = cit.iterT;
+    if (iterT.kind === "object")
+        return null;
+    const field = lowerer.shapes.get(iterT.shapeId).fields.find((f) => f.name === "next");
+    return {
+        kind: "recordGet",
+        obj: itRef,
+        shapeId: iterT.shapeId,
+        field: "next",
+        type: field.type,
+        loc,
+    };
+}
+/** The `it.next()` step of a class iterator: an ordinary (possibly
+ * virtual) method call, or the call of `next`, the object-literal
+ * iterator's `next` that classIteratorNextRead read when it opened. */
+export function classIteratorNextCall(lowerer, cit, itRef, next, loc) {
+    if (next === null || next.type.kind !== "func")
+        return classIteratorMethodCall(lowerer, cit, "next", itRef, loc);
+    return { kind: "callValue", callee: next, args: [], type: next.type.ret, loc };
+}
+/** `it.next()` or `it.return()` of a class iterator: a (possibly virtual)
+ * method call of an iterator class, or the call of an object-literal
+ * iterator's function field. */
+export function classIteratorMethodCall(lowerer, cit, method, itRef, loc) {
+    const iterT = cit.iterT;
+    if (iterT.kind === "object") {
+        const ret = method === "next"
+            ? cit.resultT
+            : findMethodOn(lowerer, lowerer.classes.get(iterT.className), "return").sig.ret;
+        return accessorCall(lowerer, iterT.className, method, itRef, [], ret, loc);
+    }
+    const field = lowerer.shapes.get(iterT.shapeId).fields.find((f) => f.name === method);
+    const fnT = field.type;
+    return {
+        kind: "callValue",
+        callee: {
+            kind: "recordGet",
+            obj: itRef,
+            shapeId: iterT.shapeId,
+            field: method,
+            type: fnT,
+            loc,
+        },
+        args: [],
+        type: fnT.ret,
+        loc,
+    };
 }
 /** `recv[Symbol.iterator]()` as an ordinary method call. */
 export function classIteratorOpenCall(lowerer, cit, recv, loc) {
@@ -6874,13 +6983,16 @@ export function classIteratorOpenCall(lowerer, cit, recv, loc) {
  * 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);
+    // A spread takes every value, so it never closes the iterator.
+    const cit = classIteratorOf(lowerer, src.type, { records: true, close: true });
     if (!cit)
         return null;
     const outElem = elemT ?? cit.valueT;
     // Probe the element coercion purely: identical types, or an arm of a
     // union destination (the wrap coerceToExpected applies below).
-    if (!typeEquals(outElem, cit.valueT)) {
+    // A checked-dynamic value (`IteratorResult<T>`'s value is `T | any`)
+    // converts to the destination element with a check.
+    if (!typeEquals(outElem, cit.valueT) && cit.valueT.kind !== "dyn") {
         if (outElem.kind !== "union" || lowerer.armTag(outElem.unionId, cit.valueT) < 0)
             return null;
     }
@@ -6893,6 +7005,8 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
         const recvT = { kind: "object", className: cit.className };
         const recvRef = { kind: "varRef", localId: "r.0", type: recvT, loc };
         const itRef = { kind: "varRef", localId: "it.0", type: cit.iterT, loc };
+        const nextRead = classIteratorNextRead(lowerer, cit, itRef, loc);
+        const nextRef = nextRead ? varRef("next.0", nextRead.type, loc) : null;
         const outRef = { kind: "varRef", localId: "out.0", type: outT, loc };
         const resRef = { kind: "varRef", localId: "res.0", type: cit.resultT, loc };
         const valueRead = {
@@ -6907,7 +7021,7 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
             {
                 kind: "varDecl",
                 localId: "res.0",
-                init: classIteratorNextCall(lowerer, cit, itRef, loc),
+                init: classIteratorNextCall(lowerer, cit, itRef, nextRef, loc),
                 loc,
             },
             ...(cit.hasDone
@@ -6948,6 +7062,7 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
             locals: [
                 { id: "r.0", name: "r", type: recvT, mutable: false },
                 { id: "it.0", name: "it", type: cit.iterT, mutable: false },
+                ...(nextRead ? [{ id: "next.0", name: "next", type: nextRead.type, mutable: false }] : []),
                 { id: "out.0", name: "out", type: outT, mutable: false },
                 { id: "res.0", name: "res", type: cit.resultT, mutable: true },
             ],
@@ -6964,6 +7079,9 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
                     init: classIteratorOpenCall(lowerer, cit, recvRef, loc),
                     loc,
                 },
+                ...(nextRead
+                    ? [{ kind: "varDecl", localId: "next.0", init: nextRead, loc }]
+                    : []),
                 {
                     kind: "while",
                     cond: { kind: "boolLit", value: true, type: BOOL, loc },
@@ -6993,7 +7111,7 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
  * 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}`;
+    const key = `it:${cit.iterT.kind === "object" ? cit.iterT.className : typeKey(cit.iterT)}`;
     let name = lowerer.iterDrainHelpers.get(key);
     if (!name) {
         name = keyedHelperName(lowerer, "%iter.drain", key);
@@ -7005,7 +7123,7 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
             {
                 kind: "varDecl",
                 localId: "res.0",
-                init: classIteratorNextCall(lowerer, cit, itRef, loc),
+                init: classIteratorNextCall(lowerer, cit, itRef, null, loc),
                 loc,
             },
             ...(cit.hasDone
@@ -7907,22 +8025,51 @@ export function lowerSuperMethodCall(lowerer, call, access) {
         lowerer.unsupported("SC1080", access);
     const loc = locOf(call);
     const thisRef = { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc };
-    if (lowerer.prototypeMethodAccesses.has(access.name.text)) {
-        const prototype = classPrototypeData(lowerer, cls.base, loc);
-        if (prototype) {
-            const callee = {
-                kind: "dynKeyGet",
-                value: prototype,
-                key: { kind: "strLit", value: access.name.text, type: STRING, loc },
-                type: DYN,
-                loc,
-            };
+    // A method whose `this` is the call-site receiver (a JavaScript class's
+    // receiver-independent method value, reflectedClassMethodValue) looks the
+    // method up on the base class's complete prototype, as `super` reads
+    // [[HomeObject]].[[Prototype]], and calls it with that receiver.
+    const dynamicThis = thisRef.type.kind === "dyn";
+    // While no code reads a prototype method by name (which could replace it),
+    // that method is the declaring class's own: its receiver-independent value
+    // is called directly. Reflecting the base's whole prototype instead would
+    // put its members on the prototype chain of every subclass instance's
+    // property bag, ahead of the subclasses' own compiled overrides.
+    const declared = dynamicThis && !lowerer.prototypeMethodAccesses.has(access.name.text)
+        ? reflectedClassMethodValue(lowerer, found.declarer, access.name.text)
+        : null;
+    if (dynamicThis || lowerer.prototypeMethodAccesses.has(access.name.text)) {
+        const prototype = declared
+            ? null
+            : dynamicThis && cls.base.decl
+                ? reflectClassPrototype(lowerer, cls.base, loc, classValueRef(lowerer, cls.base, access))
+                : classPrototypeData(lowerer, cls.base, loc);
+        if (declared || prototype) {
+            const callee = declared
+                ? lowerer.coerceToExpected(declared, DYN)
+                : {
+                    kind: "dynKeyGet",
+                    value: prototype,
+                    key: { kind: "strLit", value: access.name.text, type: STRING, loc },
+                    type: DYN,
+                    loc,
+                };
+            // Spread arguments are spread into the dynamic call, as in a dynamic method call.
+            const spreads = [];
+            const args = call.arguments.nodes.map((arg, index) => {
+                if (!ts.isSpreadElement(arg))
+                    return lowerer.lowerExprExpecting(arg, DYN);
+                const spelling = ts.getTextOfNode(arg.expression);
+                spreads.push({ arg: index, what: spelling });
+                return checkedIterableSpread(lowerer, lowerer.lowerExpr(arg.expression), spelling, loc);
+            });
             const value = {
                 kind: "dynCall",
                 callee,
                 receiver: lowerer.coerceToExpected(thisRef, DYN),
                 calleeName: ts.getTextOfNode(access),
-                args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                args,
+                ...(spreads.length > 0 ? { spreads } : {}),
                 type: DYN,
                 loc,
             };
@@ -8240,6 +8387,59 @@ function assignedThisFieldType(lowerer, expr) {
     }
     return lowerer.currentClass?.fields.get(parent.left.name.text) ?? null;
 }
+/** `new arr[i](args)` through a narrowed element read: an interned lifted
+ * function takes the read and the completed arguments, which evaluate in
+ * that order as call arguments, then runs the check and constructs. JS
+ * evaluates the arguments before it checks that the callee constructs, and
+ * the arguments stay in the one call, where a spread's argument pack lives
+ * until every argument has read it. */
+function checkedElementConstruction(lowerer, info, narrowed, args, loc) {
+    const type = { kind: "object", className: info.def.name };
+    const key = `newChecked:${narrowed.check}:${info.def.name}:${args.map((a) => typeKey(a.type)).join(",")}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        name = keyedHelperName(lowerer, "%new.checked", key);
+        lowerer.valueHelpers.set(key, name);
+        const params = [
+            { localId: "value", name: "value", type: narrowed.unionT },
+            { localId: "message", name: "message", type: STRING },
+            ...args.map((arg, i) => ({ localId: `arg.${i}`, name: `arg${i}`, type: arg.type })),
+        ];
+        lowerer.liftedFns.push({
+            name,
+            params,
+            returnType: type,
+            locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "newValue",
+                        callee: {
+                            kind: "call",
+                            callee: narrowed.check,
+                            args: [varRef("value", narrowed.unionT, loc), varRef("message", STRING, loc)],
+                            type: narrowed.calleeT,
+                            loc,
+                        },
+                        args: params.slice(2).map((p) => varRef(p.localId, p.type, loc)),
+                        type,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return {
+        kind: "call",
+        callee: name,
+        args: [narrowed.read, narrowed.message, ...args],
+        type,
+        loc,
+    };
+}
 /** Map, Set and the error classes construct in lowerNew's identifier
  * branch, which a module member alias of one (`new mod.M()`) also takes. */
 function isCollectionOrErrorClass(ref) {
@@ -8247,9 +8447,9 @@ function isCollectionOrErrorClass(ref) {
 }
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
-    // A dependency's deprecated `new Buffer(...)` fallback (containers/bytes.ts).
+    // The deprecated `new Buffer(...)` (containers/bytes.ts).
     {
-        const buffer = lowerNodeModulesBufferConstruct(lowerer, expr);
+        const buffer = lowerBufferConstruct(lowerer, expr);
         if (buffer)
             return buffer;
     }
@@ -8277,7 +8477,7 @@ export function lowerNew(lowerer, expr) {
     const worker = lowerWorkerNew(lowerer, expr);
     if (worker)
         return worker;
-    const readlineUi = lowerReadlineUiNew(lowerer, expr);
+    const readlineUi = lowerReadlineUiNew(lowerer, expr) ?? lowerReadlineInterfaceNew(lowerer, expr);
     if (readlineUi)
         return readlineUi;
     const channel = lowerMessageChannelNew(lowerer, expr) ?? lowerBroadcastChannelNew(lowerer, expr);
@@ -8348,19 +8548,39 @@ export function lowerNew(lowerer, expr) {
         lowerer.isStdlibGlobal(expr.expression.expression, "Intl")) {
         const args = expr.arguments?.nodes ?? [];
         const undefinedArg = (arg) => (lowerer.typeOf(arg).flags & ts.TypeFlags.Undefined) !== 0;
-        if (args.length > 2 || (args[0] && !undefinedArg(args[0]))) {
-            lowerer.noLowering("Intl.Segmenter locale negotiation", expr, "omit the locale or pass undefined for default Unicode grapheme segmentation");
-        }
+        // A literal language tag: Unicode grapheme clusters have no locale
+        // tailoring. Only tags of the form language[-script][-region] are
+        // accepted; each is well-formed, so Node constructs the segmenter
+        // without the RangeError a malformed tag throws.
+        const literalLocale = (arg) => ts.isStringLiteralLike(arg) &&
+            /^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?$/.test(arg.text);
+        if (args.length > 2 || (args[0] && !undefinedArg(args[0]) && !literalLocale(args[0]))) {
+            lowerer.noLowering("Intl.Segmenter locale negotiation", expr, "omit the locale, pass undefined, or pass one language tag as a string literal");
+        }
+        // JavaScript dependencies may construct word and sentence segmenters
+        // that they use only on some paths (pi-tui's shared word segmenter):
+        // the construction compiles and their segment() throws SC2020.
+        // TypeScript sources keep the build-time refusal.
+        const granularities = isJsSourceFile(ts.getSourceFileOfNode(expr))
+            ? ["grapheme", "word", "sentence"]
+            : ["grapheme"];
         const options = args[1];
-        if (options &&
-            !undefinedArg(options) &&
-            !(ts.isObjectLiteralExpression(options) &&
-                options.properties.nodes.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');
+        let granularity = "grapheme";
+        if (options && !undefinedArg(options)) {
+            // An object literal of `granularity` entries (none: the default; a
+            // repeated key: the last one, as in JavaScript).
+            if (!ts.isObjectLiteralExpression(options))
+                lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options and { granularity: "grapheme" }; word and sentence segmentation remain unsupported');
+            for (const property of options.properties.nodes) {
+                if (!ts.isPropertyAssignment(property) ||
+                    !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ||
+                    property.name.text !== "granularity" ||
+                    !ts.isStringLiteral(property.initializer) ||
+                    !granularities.includes(property.initializer.text)) {
+                    lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options and { granularity: "grapheme" }; word and sentence segmentation remain unsupported');
+                }
+                granularity = property.initializer.text;
+            }
         }
         // Explicit undefined expressions can carry effects; retain argument order.
         const stmts = args.map((arg) => {
@@ -8371,7 +8591,22 @@ export function lowerNew(lowerer, expr) {
                 loc: locOf(arg),
             };
         });
-        const result = { kind: "libCall", fn: "intl.segmenterNew", args: [], type: DYN, loc };
+        let result = { kind: "libCall", fn: "intl.segmenterNew", args: [], type: DYN, loc };
+        // A word or sentence segmenter carries its segment() refusal, which
+        // coverage lists as deferred to runtime.
+        if (granularity !== "grapheme") {
+            const surface = `Intl.Segmenter segmentation with granularity '${granularity}'`;
+            lowerer.runtimeFences.push(noLoweringDiag(surface, loc, "only grapheme segmenters segment; word and sentence segmenters construct"));
+            const line = ts.getLineAndCharacterOfPosition(ts.getSourceFileOfNode(expr), loc.start).line;
+            const refusal = `${surface} is not supported yet [SC2020 at ${loc.file}:${line + 1}]`;
+            result = {
+                kind: "libCall",
+                fn: "intl.segmenterRefusing",
+                args: [strLit(refusal, loc)],
+                type: DYN,
+                loc,
+            };
+        }
         return stmts.length ? { kind: "seqExpr", stmts, result, type: DYN, loc } : result;
     }
     // A package declaration without a compiled constructor cannot provide
@@ -8535,6 +8770,47 @@ export function lowerNew(lowerer, expr) {
         if (agent)
             return agent;
     }
+    // `new crypto.X509Certificate(data)` — the Dirent-style data record:
+    // the certificate's lowered members (fingerprint — the SHA-1 of the
+    // DER, uppercase colon-separated — plus the validFrom/validTo
+    // validity window in Node's ASN1_TIME_print shape) compute AT
+    // CONSTRUCTION, when Node parses too, so unparseable input throws
+    // Node's exact PEM error here (ERR_OSSL_PEM_NO_START_LINE) and the
+    // handle never exists. Both import forms (`crypto.X509Certificate`
+    // through the namespace, named `X509Certificate`); Buffer input only
+    // — the readFileSync idiom. mapType interns the matching record, so
+    // locals and the composed member reads all flow. The data argument
+    // feeds THREE field computations, so construction goes through an
+    // interned helper whose parameter evaluates it exactly once.
+    // It runs before the standard-library constructor fence below, which
+    // also sees `const X = require("crypto").X509Certificate` as the
+    // builtin class.
+    {
+        const callee = expr.expression;
+        const isX509 = (ts.isPropertyAccessExpression(callee) &&
+            callee.name.text === "X509Certificate" &&
+            lowerer.builtinNamespaceModuleOf(callee.expression) === "crypto") ||
+            (ts.isIdentifier(callee) &&
+                (() => {
+                    const bi = lowerer.builtinImportOf(callee);
+                    return bi?.module === "crypto" && bi.member === "X509Certificate";
+                })());
+        if (isX509) {
+            const args = expr.arguments?.nodes ?? [];
+            if (args.length !== 1) {
+                lowerer.noLowering("X509Certificate with this argument shape", expr, "the supported form is new X509Certificate(readFileSync(path))");
+            }
+            const data = lowerer.lowerExpr(args[0]);
+            const isBytes = data.type.kind === "bytes" && data.type.elem === "u8";
+            if (!isBytes && data.type.kind !== "string") {
+                lowerer.noLowering(`X509Certificate over '${lowerer.fmt(data.type)}' data`, args[0], "pass the certificate Buffer or PEM string (an fs.readFileSync result)");
+            }
+            const t = lowerer.mapTypeOf(lowerer.typeOf(expr));
+            if (t?.kind !== "record")
+                lowerer.badType(expr, lowerer.typeOf(expr));
+            return x509RecordCall(lowerer, data, t, loc);
+        }
+    }
     if (ts.isIdentifier(expr.expression) ||
         (ts.isPropertyAccessExpression(expr.expression) &&
             ts.isIdentifier(expr.expression.name) &&
@@ -8547,7 +8823,9 @@ export function lowerNew(lowerer, expr) {
         if (ts.isIdentifier(expr.expression))
             fenceEarlyAliasUse(lowerer, expr.expression, expr);
         const identifier = ts.isIdentifier(expr.expression) ? expr.expression : expr.expression.name;
-        const symbol = ts.isIdentifier(identifier) ? lowerer.resolveValueSymbol(identifier) : null;
+        // `const SD = require("string_decoder").StringDecoder; new SD()`
+        // constructs the member, as a named import of it does.
+        const symbol = builtinMemberBindingTarget(lowerer, ts.isIdentifier(identifier) ? lowerer.resolveValueSymbol(identifier) : null);
         if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Array")) {
             return lowerArrayConstructor(lowerer, expr, expr.arguments?.nodes ?? []);
         }
@@ -8825,8 +9103,31 @@ export function lowerNew(lowerer, expr) {
             if (arg.type.kind === "string") {
                 return { kind: "libCall", fn: "date.newString", args: [arg], type: DATE_T, loc };
             }
+            // new Date(date): a new Date object with the same time value.
             if (arg.type.kind === "date") {
-                return arg;
+                const time = { kind: "libCall", fn: "date.getTime", args: [arg], type: F64, loc };
+                return { kind: "libCall", fn: "date.newMs", args: [time], type: DATE_T, loc };
+            }
+            // A union (`Date | string | number`) or checked-dynamic value: the
+            // runtime's constructor reads a Date's time value, parses a string
+            // and converts anything else to a primitive and a number.
+            if ((arg.type.kind === "union" || arg.type.kind === "dyn") &&
+                lowerer.dynConvertible(arg.type)) {
+                const value = {
+                    kind: "libCall",
+                    fn: "date.nativeNewValue",
+                    args: [
+                        {
+                            kind: "dynArrLit",
+                            elems: [lowerer.coerceToExpected(arg, DYN)],
+                            type: DYN,
+                            loc,
+                        },
+                    ],
+                    type: DYN,
+                    loc,
+                };
+                return { kind: "libCall", fn: "date.checkedValue", args: [value], type: DATE_T, loc };
             }
             lowerer.noLowering(`new Date of '${lowerer.fmt(arg.type)}' values`, args[0], "pass milliseconds, a date string, or another Date value", symbol);
         }
@@ -8952,7 +9253,12 @@ export function lowerNew(lowerer, expr) {
             // expression). The CONTEXTUAL type carries the annotation — adopt
             // it when it is a supported map. TS type arguments keep winning:
             // their expression type already maps.
-            if (mapped?.kind !== "map" || contextualSeed) {
+            const inferred = initializedCollectionType(lowerer, expr);
+            if (inferred) {
+                tsType = inferred;
+                mapped = lowerer.mapTypeOf(inferred);
+            }
+            else if (mapped?.kind !== "map" || contextualSeed) {
                 const ctx = lowerer.checker.getContextualType(expr);
                 const ctxMapped = ctx ? lowerer.mapTypeOf(ctx) : null;
                 if (ctx && ctxMapped?.kind === "map") {
@@ -9005,7 +9311,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, functions, ` +
-                    `typed arrays, arrays, promises, Maps, Sets, or supported unions and checked values)`);
+                    `typed arrays, arrays, promises, Dates, Maps, Sets, or supported unions and checked values)`);
             }
             lowerer.badType(expr, tsType);
         }
@@ -9062,7 +9368,8 @@ export function lowerNew(lowerer, expr) {
         // `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")) {
-            const tsType = lowerer.typeOf(expr);
+            const inferred = initializedCollectionType(lowerer, expr);
+            const tsType = inferred ?? lowerer.typeOf(expr);
             let mapped = lowerer.mapTypeOf(tsType);
             const fieldType = assignedThisFieldType(lowerer, expr);
             if (mapped?.kind !== "set" && fieldType?.kind === "set")
@@ -9123,15 +9430,21 @@ export function lowerNew(lowerer, expr) {
             lowerer.badType(expr, tsType);
         }
         // `new AsyncLocalStorage()` (node:async_hooks): a fresh store id —
-        // an f64 handle (type-mapper.ts), the Channel story. Construction options
-        // ({ defaultValue, name }) have no lowering yet.
+        // an f64 handle (type-mapper.ts), the Channel story. The options form
+        // ({ defaultValue, name }) passes the options object as a dyn value.
         if (symbol !== null &&
             ts.symbolName(symbol) === "AsyncLocalStorage" &&
             lowerer.isStdlibSymbol(symbol)) {
-            if ((expr.arguments?.nodes.length ?? 0) > 0) {
-                lowerer.noLowering("new AsyncLocalStorage(options)", expr, "the zero-argument constructor is the supported form (defaultValue/name options have no lowering yet)");
-            }
-            return { kind: "libCall", fn: "als.new", args: [], type: F64, loc };
+            const options = expr.arguments?.nodes[0];
+            if (options === undefined)
+                return { kind: "libCall", fn: "als.new", args: [], type: F64, loc };
+            return {
+                kind: "libCall",
+                fn: "als.newOptions",
+                args: [lowerAsyncLocalStorageOptions(lowerer, options)],
+                type: F64,
+                loc,
+            };
         }
         // `new Promise<T>((resolve) => ...)`: the ambient Promise constructor.
         if (symbol !== null && ts.symbolName(symbol) === "Promise" && lowerer.isStdlibSymbol(symbol)) {
@@ -9201,38 +9514,6 @@ export function lowerNew(lowerer, expr) {
         // families carry pointed hints: each states WHY no honest static
         // lowering exists (or what to use instead).
         if (lowerer.isStdlibSymbol(symbol ?? undefined)) {
-            // The deprecated `new Buffer(string, encoding?)` ctor's string arm
-            // with a NON-STRING first argument and a string second: Node
-            // throws ERR_INVALID_ARG_TYPE synchronously (and DEP0005 never
-            // fires on this throwing path, so the compiled silence matches).
-            // Every other new Buffer form keeps the fence below — the
-            // constructing forms would owe the deprecation warning.
-            if (expr.expression.text === "Buffer" &&
-                expr.arguments?.nodes.length === 2 &&
-                !expr.arguments.nodes.some(ts.isSpreadElement) &&
-                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[0]))?.kind !== "string" &&
-                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[1]))?.kind === "string") {
-                const first = lowerer.lowerExpr(expr.arguments.nodes[0]);
-                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
-                    // observe it before throwing, so dropping it is exact for
-                    // effect-free operands; effectful ones keep the fence.
-                    const enc = lowerer.lowerExpr(expr.arguments.nodes[1]);
-                    if (enc.kind === "strLit" || isSafeToRepeat(enc)) {
-                        return {
-                            kind: "libCall",
-                            fn: "buffer.newStringFail",
-                            args: [got],
-                            type: bytesOf("u8"),
-                            loc,
-                        };
-                    }
-                }
-            }
             const ctorHints = {
                 RegExp: "use a regex literal (/pattern/flags) — constructed regexes have no lowering",
                 String: "boxed wrapper objects have no lowering — use the string primitive (the box is only distinguishable via typeof/identity, which nothing here can honor)",
@@ -9247,79 +9528,6 @@ export function lowerNew(lowerer, expr) {
             lowerer.noLowering(`new ${expr.expression.text}`, expr, ctorHints[ts.isIdentifier(expr.expression) ? expr.expression.text : expr.expression.name.text], symbol);
         }
     }
-    // `new crypto.X509Certificate(data)` — the Dirent-style data record:
-    // the certificate's lowered members (fingerprint — the SHA-1 of the
-    // DER, uppercase colon-separated — plus the validFrom/validTo
-    // validity window in Node's ASN1_TIME_print shape) compute AT
-    // CONSTRUCTION, when Node parses too, so unparseable input throws
-    // Node's exact PEM error here (ERR_OSSL_PEM_NO_START_LINE) and the
-    // handle never exists. Both import forms (`crypto.X509Certificate`
-    // through the namespace, named `X509Certificate`); Buffer input only
-    // — the readFileSync idiom. mapType interns the matching record, so
-    // locals and the composed member reads all flow. The data argument
-    // feeds THREE field computations, so construction goes through an
-    // interned helper whose parameter evaluates it exactly once.
-    {
-        const callee = expr.expression;
-        const isX509 = (ts.isPropertyAccessExpression(callee) &&
-            callee.name.text === "X509Certificate" &&
-            lowerer.builtinNamespaceModuleOf(callee.expression) === "crypto") ||
-            (ts.isIdentifier(callee) &&
-                (() => {
-                    const bi = lowerer.builtinImportOf(callee);
-                    return bi?.module === "crypto" && bi.member === "X509Certificate";
-                })());
-        if (isX509) {
-            const args = expr.arguments?.nodes ?? [];
-            if (args.length !== 1) {
-                lowerer.noLowering("X509Certificate with this argument shape", expr, "the supported form is new X509Certificate(readFileSync(path))");
-            }
-            const data = lowerer.lowerExpr(args[0]);
-            const isBytes = data.type.kind === "bytes" && data.type.elem === "u8";
-            if (!isBytes && data.type.kind !== "string") {
-                lowerer.noLowering(`X509Certificate over '${lowerer.fmt(data.type)}' data`, args[0], "pass the certificate Buffer or PEM string (an fs.readFileSync result)");
-            }
-            const t = lowerer.mapTypeOf(lowerer.typeOf(expr));
-            if (t?.kind !== "record")
-                lowerer.badType(expr, lowerer.typeOf(expr));
-            const key = `x509.record:${isBytes ? "bytes" : "str"}`;
-            let helper = lowerer.valueHelpers.get(key);
-            if (!helper) {
-                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 };
-                const field = (name, fn) => ({
-                    name,
-                    value: { kind: "libCall", fn, args: [dRef], type: STRING, loc },
-                });
-                lowerer.liftedFns.push({
-                    name: helper,
-                    params: [{ localId: "d.0", name: "d", type: dataT }],
-                    returnType: t,
-                    locals: [{ id: "d.0", name: "d", type: dataT, mutable: false }],
-                    body: [
-                        {
-                            kind: "return",
-                            value: {
-                                kind: "recordLit",
-                                fields: [
-                                    field("fingerprint", isBytes ? "crypto.x509Fingerprint" : "crypto.x509FingerprintStr"),
-                                    field("validFrom", isBytes ? "crypto.x509ValidFrom" : "crypto.x509ValidFromStr"),
-                                    field("validTo", isBytes ? "crypto.x509ValidTo" : "crypto.x509ValidToStr"),
-                                ],
-                                type: t,
-                                loc,
-                            },
-                            loc,
-                        },
-                    ],
-                    loc,
-                });
-            }
-            return { kind: "call", callee: helper, args: [data], type: t, loc };
-        }
-    }
     // `new X(...)` through a class VALUE (a classval-typed binding, array
     // element, map read, param): the newValue dispatch through the class
     // object's construct thunk. Arguments complete against the STATIC
@@ -9358,9 +9566,108 @@ export function lowerNew(lowerer, expr) {
             if (info.generic) {
                 lowerer.unsupported("SC1090", expr, "constructing through a class value of an uninstantiated generic type (annotate the slot with a concrete instantiation — e.g. 'new (v: number) => Box<number>')");
             }
-            const callee = lowerer.lowerExpr(expr.expression);
+            let callee = lowerer.lowerExpr(expr.expression);
             if (callee.type.kind === "dyn")
                 return lowerCheckedConstructor(lowerer, expr, callee);
+            /** The union-typed element read a narrowing check guards, and the
+             * check (`%new.callee`) that yields the class value or throws. */
+            let narrowedCallee = null;
+            // An array element read (`new T[0]()` over `[Dog, Animal]`, whose
+            // checker type is the common base) keeps the undefined an index past
+            // the end reads: the class value is narrowed out with a check, which
+            // throws a TypeError for undefined.
+            if (callee.type.kind === "union") {
+                const arms = lowerer.unions.get(callee.type.unionId)?.arms ?? [];
+                const classArms = arms.filter((arm) => arm.kind === "classval");
+                if (classArms.length === 1 &&
+                    classArms[0].kind === "classval" &&
+                    classArms[0].className === calleeT.className &&
+                    arms.every((arm) => arm.kind === "classval" || arm.kind === "undefinedT")) {
+                    const unionT = callee.type;
+                    const helper = lowerer.narrowedArmHelper(unionT.unionId, calleeT, callee.loc);
+                    if (helper) {
+                        const loc = callee.loc;
+                        const name = `%new.callee:${unionT.unionId}`;
+                        if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+                            const undefinedTag = lowerer.armTag(unionT.unionId, UNDEFINED_T);
+                            const value = { kind: "varRef", localId: "value", type: unionT, loc };
+                            lowerer.liftedFns.push({
+                                name,
+                                params: [
+                                    { localId: "value", name: "value", type: unionT },
+                                    { localId: "message", name: "message", type: STRING },
+                                ],
+                                locals: [
+                                    { id: "value", name: "value", type: unionT, mutable: false },
+                                    { id: "message", name: "message", type: STRING, mutable: false },
+                                ],
+                                returnType: calleeT,
+                                body: [
+                                    ...(undefinedTag >= 0
+                                        ? [
+                                            {
+                                                kind: "if",
+                                                cond: {
+                                                    kind: "unionIsTag",
+                                                    unionId: unionT.unionId,
+                                                    tag: undefinedTag,
+                                                    negated: false,
+                                                    value,
+                                                    type: BOOL,
+                                                    loc,
+                                                },
+                                                then: [
+                                                    {
+                                                        kind: "throw",
+                                                        value: {
+                                                            kind: "libCall",
+                                                            fn: "error.new",
+                                                            args: [{ kind: "varRef", localId: "message", type: STRING, loc }],
+                                                            type: { kind: "object", className: "%TypeError" },
+                                                            loc,
+                                                        },
+                                                        loc,
+                                                    },
+                                                ],
+                                                else_: null,
+                                                loc,
+                                            },
+                                        ]
+                                        : []),
+                                    {
+                                        kind: "return",
+                                        value: lowerer.checkedNarrowCall(helper, value, calleeT, loc),
+                                        loc,
+                                    },
+                                ],
+                                loc,
+                            });
+                        }
+                        // JavaScript evaluates the arguments before it checks that the
+                        // callee constructs, so the check runs at the construction
+                        // (checkedElementConstruction).
+                        narrowedCallee = {
+                            read: callee,
+                            check: name,
+                            unionT,
+                            calleeT,
+                            message: {
+                                kind: "strLit",
+                                value: `${expr.expression.getText()} is not a constructor`,
+                                type: STRING,
+                                loc,
+                            },
+                        };
+                        callee = {
+                            kind: "call",
+                            callee: name,
+                            args: [callee, narrowedCallee.message],
+                            type: calleeT,
+                            loc,
+                        };
+                    }
+                }
+            }
             if (callee.type.kind !== "classval")
                 lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
             lowerer.noteEdge(classValueConstructor(info.def).fn);
@@ -9386,13 +9693,15 @@ export function lowerNew(lowerer, expr) {
             refuseInheritedBuiltinCtorArgs(lowerer, info, expr);
             defineClassValueConstruct(lowerer, info);
             const args = lowerer.completeArgs(expr.arguments?.nodes ?? [], classValueParams(info), loc, expr);
-            const built = constructedFromValue(lowerer, info, {
-                kind: "newValue",
-                callee,
-                args,
-                type: { kind: "object", className: info.def.name },
-                loc,
-            }, expr);
+            const built = constructedFromValue(lowerer, info, narrowedCallee !== null
+                ? checkedElementConstruction(lowerer, info, narrowedCallee, args, loc)
+                : {
+                    kind: "newValue",
+                    callee,
+                    args,
+                    type: { kind: "object", className: info.def.name },
+                    loc,
+                }, expr);
             // A runtime class slot widened from a union (`[Readable, Writable]`'s
             // elements hold EventEmitter values): the checker types the result as
             // the union of the arms' instances, which the checked class view
@@ -9527,14 +9836,149 @@ function genericFieldFnNodeOf(member) {
     }
     return null;
 }
+/** The lifted `new crypto.X509Certificate(d)` constructor: raw decodes the
+ * input once (Node's PEM error throws here), and every other field reads
+ * raw. subjectAltName, infoAccess and signatureAlgorithm hold undefined
+ * where the runtime answers "". */
+/** The X509Certificate record `t` built from `data`, a certificate Buffer
+ * (PEM or DER) or PEM string, through the interned constructor helper.
+ * `der` marks a Buffer known to hold a certificate's DER (a TLS socket's),
+ * which is read without looking for PEM armor inside it. */
+export function x509RecordCall(lowerer, data, t, loc, der = false) {
+    const isBytes = data.type.kind === "bytes" && data.type.elem === "u8";
+    const key = `x509.record:${der ? "der" : isBytes ? "bytes" : "str"}`;
+    let helper = lowerer.valueHelpers.get(key);
+    if (!helper) {
+        helper = keyedHelperName(lowerer, "%x509.record", key);
+        lowerer.valueHelpers.set(key, helper);
+        lowerer.liftedFns.push(x509RecordHelper(lowerer, helper, data.type, t, isBytes, der, loc));
+    }
+    return { kind: "call", callee: helper, args: [data], type: t, loc };
+}
+function x509RecordHelper(lowerer, name, dataT, t, isBytes, der, loc) {
+    const shape = lowerer.shapes.get(t.shapeId);
+    if (!shape)
+        throw new InternalCompilerError("lowerer bug: X509Certificate shape unregistered");
+    const raw = { kind: "varRef", localId: "raw.0", type: BYTES_U8, loc };
+    const call = (fn, type) => ({
+        kind: "libCall",
+        fn,
+        args: [raw],
+        type,
+        loc,
+    });
+    const locals = [
+        { id: "d.0", name: "d", type: dataT, mutable: false },
+        { id: "raw.0", name: "raw", type: BYTES_U8, mutable: false },
+    ];
+    const decls = [
+        {
+            kind: "varDecl",
+            localId: "raw.0",
+            init: {
+                kind: "libCall",
+                fn: der ? "crypto.x509RawDer" : isBytes ? "crypto.x509Raw" : "crypto.x509RawStr",
+                args: [{ kind: "varRef", localId: "d.0", type: dataT, loc }],
+                type: BYTES_U8,
+                loc,
+            },
+            loc,
+        },
+    ];
+    const validTime = (fn) => ({
+        kind: "libCall",
+        fn: "date.newString",
+        args: [call(fn, STRING)],
+        type: DATE_T,
+        loc,
+    });
+    const values = {
+        ca: () => call("crypto.x509Ca", BOOL),
+        fingerprint: () => call("crypto.x509Fingerprint", STRING),
+        fingerprint256: () => call("crypto.x509Fingerprint256", STRING),
+        fingerprint512: () => call("crypto.x509Fingerprint512", STRING),
+        subject: () => call("crypto.x509Subject", STRING),
+        subjectAltName: (type) => optionalText("san", "crypto.x509SubjectAltName", type),
+        infoAccess: (type) => optionalText("access", "crypto.x509InfoAccess", type),
+        issuer: () => call("crypto.x509Issuer", STRING),
+        raw: () => raw,
+        serialNumber: () => call("crypto.x509SerialNumber", STRING),
+        signatureAlgorithm: (type) => optionalText("sigalg", "crypto.x509SignatureAlgorithm", type),
+        signatureAlgorithmOid: () => call("crypto.x509SignatureAlgorithmOid", STRING),
+        validFrom: () => call("crypto.x509ValidFrom", STRING),
+        validFromDate: () => validTime("crypto.x509ValidFrom"),
+        validTo: () => call("crypto.x509ValidTo", STRING),
+        validToDate: () => validTime("crypto.x509ValidTo"),
+        [X509_PUBLIC_KEY_FIELD]: () => ({
+            kind: "dynFrom",
+            value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+            type: DYN,
+            loc,
+        }),
+        // A copy: writes into `raw` must not reach the methods.
+        [X509_DER_FIELD]: () => call("crypto.x509RawDer", BYTES_U8),
+    };
+    /** A string | undefined field: the runtime's text, or undefined for "". */
+    function optionalText(local, fn, type) {
+        if (type.kind !== "union")
+            throw new InternalCompilerError("lowerer bug: X509Certificate optional field type");
+        const def = lowerer.unions.get(type.unionId);
+        const stringTag = def ? def.arms.findIndex((a) => a.kind === "string") : -1;
+        const undefinedTag = def ? def.arms.findIndex((a) => a.kind === "undefinedT") : -1;
+        if (stringTag < 0 || undefinedTag < 0)
+            throw new InternalCompilerError("lowerer bug: X509Certificate optional field arms");
+        const id = `${local}.0`;
+        locals.push({ id, name: local, type: STRING, mutable: false });
+        decls.push({ kind: "varDecl", localId: id, init: call(fn, STRING), loc });
+        const text = { kind: "varRef", localId: id, type: STRING, loc };
+        return {
+            kind: "ternary",
+            cond: {
+                kind: "strEq",
+                negated: false,
+                left: text,
+                right: { kind: "strLit", value: "", type: STRING, loc },
+                type: BOOL,
+                loc,
+            },
+            then: {
+                kind: "unionWrap",
+                unionId: type.unionId,
+                tag: undefinedTag,
+                value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+                type,
+                loc,
+            },
+            else_: { kind: "unionWrap", unionId: type.unionId, tag: stringTag, value: text, type, loc },
+            type,
+            loc,
+        };
+    }
+    const fields = shape.fields.map((f) => {
+        const value = values[f.name];
+        if (!value)
+            throw new InternalCompilerError(`lowerer bug: X509Certificate field ${f.name}`);
+        return { name: f.name, value: value(f.type) };
+    });
+    return {
+        name,
+        params: [{ localId: "d.0", name: "d", type: dataT }],
+        returnType: t,
+        locals,
+        body: [...decls, { kind: "return", value: { kind: "recordLit", fields, type: t, loc }, loc }],
+        loc,
+    };
+}
 /** Whether a JavaScript class's own binding is the target of
- * `Object.defineProperty`/`defineProperties` in its file
- * (`Object.defineProperty(Definition, "name", { value })`): its constructor
+ * `Object.defineProperty`/`defineProperties` or `Reflect.deleteProperty` in
+ * its file (`Object.defineProperty(Definition, "name", { value })`,
+ * `Reflect.deleteProperty(Response, "getResponseState")`): 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"))
+    if (name === undefined ||
+        (!sf.text.includes("definePropert") && !sf.text.includes("deleteProperty")))
         return false;
     const symbol = lowerer.checker.getSymbolAtLocation(name);
     if (symbol === undefined)
@@ -9545,9 +9989,11 @@ function definedThroughReflection(lowerer, decl) {
             return "stop";
         if (ts.isCallExpression(node) &&
             ts.isPropertyAccessExpression(node.expression) &&
-            (node.expression.name.text === "defineProperty" ||
+            (((node.expression.name.text === "defineProperty" ||
                 node.expression.name.text === "defineProperties") &&
-            lowerer.stdlibGlobalMember(node.expression, "Object") !== null) {
+                lowerer.stdlibGlobalMember(node.expression, "Object") !== null) ||
+                (node.expression.name.text === "deleteProperty" &&
+                    lowerer.stdlibGlobalMember(node.expression, "Reflect") !== null))) {
             const target = node.arguments.nodes[0];
             if (target !== undefined &&
                 ts.isIdentifier(target) &&