@scriptc/compiler 0.4.6 → 0.4.8

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

@@ -1,3 +1,5 @@
+import { isJsIteratorGlobal, iteratorPrototypeExpr, lowerIteratorNew, } from "./iterator-prototype.js";
+import { lowerWrapperNew } from "./primitive-wrappers.js";
 import { lowerAsyncLocalStorageOptions } from "./builtins/async-context.js";
 import { shapeOverlayAnnotated } from "../shape-inference/index.js";
 import { DATE_TIME_FIELD, dateRootOf, dateSuperCall, isDatePrototypeMethod, lowerDateSuperMethodCall, } from "./builtins/date-classes.js";
@@ -8,7 +10,8 @@ import { keyedHelperName } from "./stable-names.js";
 import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js";
 import { adaptPromiseExecutor } from "./promise-executor-adapter.js";
 import { dynUndefinedExpr, nodeThrowExpr, strLit, varRef } from "../../ir/build.js";
-import { constructedFromValue, constructedValue, superIntoResultSlot, } from "./constructor-returns.js";
+import { isBuiltinIdentityToken, isPrimitiveValueType, staticallyPrimitive, throwAfterEach, throwTypeError, } from "./primitive-throws.js";
+import { constructedFromValue, constructedValue, constructorPrimitiveFlag, superIntoResultSlot, } from "./constructor-returns.js";
 import { checkedIterableSpread } from "./checked-iterable-spread.js";
 import { lowerReadlineInterfaceNew, lowerReadlineUiNew } from "./builtins/readline.js";
 import { builtinMemberBindingTarget, builtinMemberRequireDecl, } from "./builtins/module-bindings.js";
@@ -28,15 +31,15 @@ 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, 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 { BIGINT_BYTES_NAMES, 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";
 import { bodyReadsArguments } from "../arguments-usage.js";
 import { errorNameAfterField, errorViewFields } from "./error-name-order.js";
-import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, } from "./call-signatures.js";
+import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, generatorParamsBindAtCall, } from "./call-signatures.js";
 import { omittedArgFor } from "./call-arguments.js";
-import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, X509_DER_FIELD, X509_PUBLIC_KEY_FIELD, } from "../type-mapper.js";
+import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, noteScopeSensitiveMapping, 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 { islandValueOrigin } from "../node-api-import.js";
@@ -61,6 +64,7 @@ import { declSymbolOf } from "./lower-modules.js";
 import { INSPECT_CUSTOM_MEMBER, classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js";
 import { lowerHttpAgentNew, lowerHttpServerNew, lowerTlsSocketNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
+import { hostGlobalNameOfRead } from "./host-globals.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
 import { hasLexicalPrivateReference, hasStaticThis, rejectStaticThis } from "./static-this.js";
 import { lowerUrlNew } from "./lower-url.js";
@@ -72,8 +76,8 @@ import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.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 { checkedClassConstruction, checkedClassConstructionPacked, primitiveCheckedConstruction, } from "./class-construction.js";
+import { initializeRuntimeStatics, hasRuntimeStatics, runtimeStaticDefines, } from "./class-runtime-statics.js";
 import { reflectedClassMethodValue, reflectedClassStaticMethodValue, } from "./class-method-values.js";
 import { identifierReadSymbol } from "./surfaces.js";
 export function returnsOnlyThis(member) {
@@ -131,13 +135,94 @@ export function returnsOnlyThisValue(member) {
     ts.forEachChild(body, visit);
     return valid;
 }
-export function functionLocalClass(decl) {
-    for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
-        if (ts.isFunctionLike(parent))
+/** True when evaluating this class definition creates a class VALUE more
+ * than once, so each evaluation must mint its own constructor object,
+ * prototype and statics. A function body runs per call, a loop body per
+ * iteration, and an instance field initializer (or constructor parameter
+ * default) per construction. A class expression nested in a STATIC member
+ * initializer, a computed key or the heritage follows its enclosing
+ * class's own evaluation, so the walk continues through those.
+ * Top-level definitions evaluated once keep the immortal template. */
+export function perEvaluationClass(decl) {
+    let child = decl;
+    for (let parent = decl.parent; parent && !ts.isSourceFile(parent); child = parent, parent = parent.parent) {
+        if (ts.isFunctionLike(parent) || ts.isClassStaticBlockDeclaration(parent))
+            return true;
+        if (ts.isForStatement(parent) ||
+            ts.isForInStatement(parent) ||
+            ts.isForOfStatement(parent) ||
+            ts.isWhileStatement(parent) ||
+            ts.isDoStatement(parent))
+            return true;
+        if ((ts.isClassDeclaration(parent) || ts.isClassExpression(parent)) && perInstanceMember(child))
             return true;
     }
     return false;
 }
+/** True when `node` — the direct child of the enclosing class on the path
+ * to a nested class definition — is evaluated once per INSTANCE: an
+ * instance field with an initializer, or a constructor whose parameters
+ * have defaults (parameter properties included). */
+function perInstanceMember(node) {
+    if (ts.isConstructorDeclaration(node))
+        return node.parameters.nodes.some((param) => param.initializer !== undefined);
+    if (!ts.isPropertyDeclaration(node) || node.initializer === undefined)
+        return false;
+    return !ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
+}
+/** `Symbol.hasInstance` over the standard global. */
+export function isSymbolHasInstanceKey(lowerer, key) {
+    let e = key;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    return (ts.isPropertyAccessExpression(e) &&
+        !e.questionDotToken &&
+        ts.isIdentifier(e.expression) &&
+        lowerer.isStdlibGlobal(e.expression, "Symbol") &&
+        ts.isIdentifier(e.name) &&
+        e.name.text === "hasInstance");
+}
+/** The static members keyed by `Symbol.hasInstance`
+ * (`static [Symbol.hasInstance](v) { … }`): defining them on the class
+ * value's own-property table gives `instanceof` its hook (the runtime
+ * consults that table, scr_dyn_has_instance_hook). */
+export function staticHasInstanceHookMembers(lowerer, decl) {
+    return decl.members.nodes.filter((member) => {
+        const name = member.name;
+        return (name !== undefined &&
+            ts.isComputedPropertyName(name) &&
+            ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ===
+                true &&
+            isSymbolHasInstanceKey(lowerer, name.expression));
+    });
+}
+/** Whether `info` or an ancestor declares a static `Symbol.hasInstance`
+ * member. Node's `instanceof` asks the hook on the constructor (inherited
+ * through the static prototype chain) and uses OrdinaryHasInstance only
+ * when no hook exists. */
+export function classDeclaresHasInstanceHook(info) {
+    for (let current = info; current; current = current.base) {
+        if (current.hasInstanceHook === true)
+            return true;
+    }
+    return false;
+}
+/** Whether `expression` reads an element of a JavaScript array whose
+ * compiled storage is checked-dynamic (`const classes = [A, B]`; the
+ * array literal of several class constructors lowers as the checked
+ * array, and an unannotated file-scope binding keeps that layout). */
+function jsCheckedDynamicArrayElement(lowerer, expression) {
+    if (!ts.isElementAccessExpression(expression))
+        return false;
+    if (!isJsSourceFile(ts.getSourceFileOfNode(expression)))
+        return false;
+    if (!ts.isIdentifier(expression.expression))
+        return false;
+    const stored = lowerer.peekLocal(expression.expression) ?? lowerer.globalOf(expression.expression);
+    if (!stored)
+        return false;
+    return (stored.type.kind === "dyn" || (stored.type.kind === "array" && stored.type.elem.kind === "dyn"));
+}
 export function storedClassValueType(lowerer, expression, visiting = new Set()) {
     if (visiting.has(expression))
         return null;
@@ -145,7 +230,7 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
     if (ts.isParenthesizedExpression(expression))
         return storedClassValueType(lowerer, expression.expression, visiting);
     if (ts.isClassExpression(expression) &&
-        !functionLocalClass(expression) &&
+        !perEvaluationClass(expression) &&
         !lowerer.collectingExprClasses.has(expression)) {
         const info = lowerer.lowerClassExpressionInfo(expression);
         return { kind: "classval", className: info.def.name };
@@ -183,13 +268,19 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
     }
     const type = lowerer.typeOf(expression);
     const mapped = lowerer.mapTypeOf(type);
+    // An element of a CHECKED-DYNAMIC JavaScript array (`const classes =
+    // [A, B]`, `both[1]`): the storage holds whichever constructor the array
+    // holds, so tsc's inferred element type — best common type spells the
+    // first — does not name the class the slot holds at run time.
+    if (mapped?.kind === "classval" && jsCheckedDynamicArrayElement(lowerer, expression))
+        return null;
     if (mapped?.kind === "classval" && !lowerer.classes.has(mapped.className)) {
         for (const signature of lowerer.checker.getConstructSignatures(type)) {
             const constructor = signature.declaration;
             const declaration = constructor && ts.isConstructorDeclaration(constructor) ? constructor.parent : undefined;
             if (declaration &&
                 ts.isClassExpression(declaration) &&
-                !functionLocalClass(declaration) &&
+                !perEvaluationClass(declaration) &&
                 !lowerer.collectingExprClasses.has(declaration)) {
                 const info = lowerer.lowerClassExpressionInfo(declaration);
                 return { kind: "classval", className: info.def.name };
@@ -1387,6 +1478,15 @@ mixin) {
         const adoptCallableBase = (expression) => {
             if (familyMode || inst || mixin)
                 return false;
+            if (isJsIteratorGlobal(lowerer, expression)) {
+                callableBase = {
+                    expression,
+                    constructorId: `%g.${className}.base`,
+                    prototypeId: `%g.${className}.basePrototype`,
+                    iterator: true,
+                };
+                return true;
+            }
             if (lowerer.computedCallableBases.has(decl)) {
                 callableBase = {
                     expression,
@@ -1461,7 +1561,13 @@ mixin) {
                 const emitterBase = lowerer.builtinEmitterInfoOf(resolved);
                 const streamBaseNs = builtinStreamInfoOf(lowerer, resolved);
                 if (emitterBase || streamBaseNs) {
-                    if (t.typeArguments?.nodes)
+                    // An EventEmitter's type argument is the listener MAP, a pure
+                    // typing aid: the emitter base is one runtime class whatever the
+                    // map says, and the map's keys never reach the layout (Node's
+                    // own generic erases at runtime), so `extends
+                    // EventEmitter<MyEvents>` adopts the same base. A stream base's
+                    // argument IS the element layout, which still has to be concrete.
+                    if (!emitterBase && t.typeArguments?.nodes)
                         lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = (emitterBase ?? streamBaseNs);
                     continue;
@@ -1652,7 +1758,12 @@ mixin) {
                 base = instBase;
                 continue;
             }
-            if (t.typeArguments?.nodes)
+            // An EventEmitter base's type argument is the listener MAP — a pure
+            // typing aid (the runtime base is one emitter class whatever the map
+            // says, and Node erases it too), so `extends EventEmitter<Events>`
+            // adopts the same base. Every other generic base still refuses:
+            // its argument can carry a layout.
+            if (t.typeArguments?.nodes && lowerer.builtinEmitterInfoOf(symbol) === null)
                 lowerer.unsupported("SC1090", t, "extending generic classes");
             if (named?.extendsArray)
                 lowerer.unsupported("SC1090", t, `extending '${t.expression.text}', a class that extends Array (one level of Array subclass compiles)`);
@@ -1674,7 +1785,7 @@ mixin) {
                 throw new PoisonError();
             }
         }
-        if (base?.localClass && !functionLocalClass(decl) && !computedBase && !factoryBaseExpression) {
+        if (base?.localClass && !perEvaluationClass(decl) && !computedBase && !factoryBaseExpression) {
             const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0];
             if (heritage)
                 factoryBaseExpression = heritage.expression;
@@ -1741,7 +1852,13 @@ mixin) {
                 decl.members.nodes.some((member) => ts.isAccessor(member) &&
                     !ts.isPrivateIdentifier(member.name) &&
                     member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
-            !decl.members.nodes.some((member) => member.name &&
+            // A private static ACCESSOR has no native storage yet, and a private
+            // static method that reads `arguments` would lose the arguments past
+            // its parameters when called through its value (`this.#m` returned by
+            // a getter): keep such a class on the static path, whose public
+            // static accessors refuse.
+            !decl.members.nodes.some((member) => (ts.isAccessor(member) ||
+                (ts.isMethodDeclaration(member) && bodyReadsArguments(member))) &&
                 ts.isPrivateIdentifier(member.name) &&
                 ts
                     .getModifiers(member)
@@ -1796,17 +1913,31 @@ mixin) {
             });
         };
         for (const member of decl.members.nodes) {
-            if ((functionLocalClass(decl) || checkedStatics) &&
+            if ((perEvaluationClass(decl) || checkedStatics) &&
                 (isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
-                    (functionLocalClass(decl) && ts.isMethodDeclaration(member))) &&
+                    (perEvaluationClass(decl) && ts.isMethodDeclaration(member))) &&
                 (ts.isClassStaticBlockDeclaration(member) ||
                     ts
                         .getModifiers(member)
                         ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) {
-                runtimeStatics.push(member);
-                continue;
+                // A private static of a declaration-level class keeps its native
+                // storage (the %C.static:#m function, the %g.s.C.#x global): the
+                // constructor object never carries a property for it, and every
+                // access brand-checks its receiver (private-statics.ts). A field
+                // also stays in runtimeStatics, so its initializer runs in source
+                // order with the constructor's other initializers.
+                const privateStatic = checkedStatics &&
+                    !perEvaluationClass(decl) &&
+                    member.name !== undefined &&
+                    ts.isPrivateIdentifier(member.name);
+                if (!privateStatic) {
+                    runtimeStatics.push(member);
+                    continue;
+                }
+                if (ts.isPropertyDeclaration(member))
+                    runtimeStatics.push(member);
             }
-            if (functionLocalClass(decl) &&
+            if (perEvaluationClass(decl) &&
                 isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                 (ts.isMethodDeclaration(member) || ts.isAccessor(member)) &&
                 member.body &&
@@ -1900,7 +2031,7 @@ mixin) {
                     }
                     staticMethods.set(member.name.text, { params: shapes, ret: ft.ret, member });
                     if (implicitMonoFile(ts.getSourceFileOfNode(decl)) &&
-                        !functionLocalClass(decl) &&
+                        !perEvaluationClass(decl) &&
                         inst === undefined &&
                         decl.typeParameters === undefined) {
                         const implicit = implicitAnyParamSymbolsOf(lowerer, member, true);
@@ -2530,7 +2661,7 @@ mixin) {
                 // name (the override stays on the vtable), a shadowed field, or
                 // a generic-class instantiation's member.
                 if (implicitMonoFile(ts.getSourceFileOfNode(decl)) &&
-                    !functionLocalClass(decl) &&
+                    !perEvaluationClass(decl) &&
                     ts.isIdentifier(member.name) &&
                     !lowerer.virtualJsMethods.has(member) &&
                     !lowerer.checkedJsOverrideMethods.has(member) &&
@@ -2741,7 +2872,7 @@ mixin) {
                     // boundary (lowerClassMethodMemberInner).
                     const ownAsync = member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
                     if (!fencedJsOverride &&
-                        !functionLocalClass(decl) &&
+                        !perEvaluationClass(decl) &&
                         overridden.sig.gen === undefined &&
                         // An async base's slot answers its promise: a Promise type, or
                         // the checked-dynamic value of an untyped async method.
@@ -2830,7 +2961,7 @@ mixin) {
                     !returnAdapters.has(mName) &&
                     (asyncMember || overridden.sig.async === true) &&
                     !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
-                    !functionLocalClass(decl) &&
+                    !perEvaluationClass(decl) &&
                     member.asteriskToken === undefined &&
                     overridden.sig.gen === undefined &&
                     !overridden.sig.abstract &&
@@ -3477,7 +3608,18 @@ mixin) {
             bodyReadsArguments(ctor)) {
             ctorParams.push({ type: DYN, mode: "arguments" });
         }
+        // A static `Symbol.hasInstance` member of a class that otherwise keeps
+        // its statics in module storage: the hook only exists if the CLASS
+        // VALUE carries it, so the member joins the runtime property table
+        // (initializeRuntimeStatics). Only the hook members are added; every
+        // other static keeps its current representation.
+        const hasInstanceHooks = staticHasInstanceHookMembers(lowerer, decl);
+        for (const member of hasInstanceHooks) {
+            if (!runtimeStatics.includes(member))
+                runtimeStatics.push(member);
+        }
         const info = {
+            ...(hasInstanceHooks.length ? { hasInstanceHook: true } : {}),
             ...(runtimeStatics.length || checkedStatics ? { runtimeStatics } : {}),
             ...(runtimePrototypeMembers.length ? { runtimePrototypeMembers } : {}),
             def: {
@@ -3622,7 +3764,7 @@ mixin) {
             lowerer.subclassLinks++;
         }
         lowerer.classes.set(className, info);
-        if (computedBase && !functionLocalClass(decl)) {
+        if (computedBase && !perEvaluationClass(decl)) {
             info.def.baseValueGlobal = `%g.${className}.computedBase`;
             lowerer.globalsList.push({
                 id: info.def.baseValueGlobal,
@@ -3631,7 +3773,7 @@ mixin) {
                 mutable: false,
             });
         }
-        if (factoryBaseExpression && !functionLocalClass(decl)) {
+        if (factoryBaseExpression && !perEvaluationClass(decl)) {
             info.def.baseValueGlobal = `%g.${className}.computedBase`;
             lowerer.globalsList.push({
                 id: info.def.baseValueGlobal,
@@ -3640,7 +3782,7 @@ mixin) {
                 mutable: false,
             });
         }
-        if (callableBase && !functionLocalClass(decl)) {
+        if (callableBase && !perEvaluationClass(decl)) {
             lowerer.globalsList.push({ id: callableBase.constructorId, name: `${className} base`, type: DYN, mutable: false }, {
                 id: callableBase.prototypeId,
                 name: `${className} base prototype`,
@@ -3741,6 +3883,9 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
         // body (`this.v = v` types the receiver as `this`, not a reference).
         // Inside an instantiation the CURRENT bindings are the arguments;
         // anywhere else the reference is honestly unmappable.
+        // The current instance's bindings ARE the arguments: the mapping
+        // belongs to that instance.
+        noteScopeSensitiveMapping();
         for (const tp of gci.typeParams) {
             const b = lowerer.typeParamBindings?.get(tp);
             if (!b)
@@ -4074,16 +4219,23 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         }, {
             kind: "assign",
             localId: prototypeId,
-            value: {
-                kind: "libCall",
-                fn: "dyn.classBasePrototype",
-                args: [{ kind: "varRef", localId: constructorId, type: DYN, loc }],
-                type: DYN,
-                loc,
-            },
+            value: info.callableBase.iterator
+                ? iteratorPrototypeExpr(loc)
+                : {
+                    kind: "libCall",
+                    fn: "dyn.classBasePrototype",
+                    args: [{ kind: "varRef", localId: constructorId, type: DYN, loc }],
+                    type: DYN,
+                    loc,
+                },
             loc,
         });
-        const prototype = classPrototypeData(lowerer, info, loc);
+        // An iterator subclass's instances are driven by the runtime's helpers,
+        // which read `next` and `return` (methods or accessors) through the
+        // instance's view: its prototype holds every member.
+        const prototype = info.callableBase.iterator && info.decl
+            ? reflectClassPrototype(lowerer, info, loc, classValueRef(lowerer, info, info.decl))
+            : classPrototypeData(lowerer, info, loc);
         if (prototype)
             out.push({ kind: "exprStmt", expr: prototype, loc });
         out.push({
@@ -4109,7 +4261,15 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         });
     }
     const items = [
-        ...info.staticFields.map((f) => ({
+        // A runtime-statics class initializes the private static fields its
+        // property table carries with its other initializers
+        // (initializeRuntimeStatics). One whose table carries only its
+        // `Symbol.hasInstance` hook keeps its native initializers here.
+        ...info.staticFields
+            .filter((f) => !(info.runtimeStatics &&
+            f.name.startsWith("#") &&
+            runtimeStaticDefines(lowerer, info, f.name)))
+            .map((f) => ({
             pos: ts.tokenStartOfNode(f.initializer),
             kind: "field",
             f,
@@ -4721,7 +4881,13 @@ export function lowerClassStaticRead(lowerer, info, name, receiver, site) {
         ["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)
+    // A statically known member that the class value's table does not carry
+    // (a class whose only runtime static is its `Symbol.hasInstance` hook)
+    // reads its own storage, as it would without the hook.
+    if (hasRuntimeStatics(info) &&
+        !found?.field &&
+        !name.startsWith("#") &&
+        (!found || runtimeStaticDefines(lowerer, info, name)))
         return {
             kind: "dynKeyGet",
             value: lowerer.coerceToExpected(classValueRef(lowerer, info, receiver), DYN),
@@ -4823,6 +4989,15 @@ function namedEvaluationName(expr) {
         return p.name.text;
     if (ts.isParameter(p) && ts.isIdentifier(p.name))
         return p.name.text;
+    // A destructuring default: `const [c = class {}] = []` and
+    // `({ c = class {} } = o)` name the class after the bound identifier. An
+    // array-literal element that is not a pattern element stays unnamed.
+    if (ts.isBindingElement(p) && p.initializer !== undefined && ts.isIdentifier(p.name))
+        return p.name.text;
+    if (ts.isShorthandPropertyAssignment(p) &&
+        p.objectAssignmentInitializer !== undefined &&
+        ts.isIdentifier(p.name))
+        return p.name.text;
     return "";
 }
 /** Each evaluation of a function-local class creates fresh private names,
@@ -4889,10 +5064,13 @@ function privateNamesOnlyOnThis(expr) {
     }
     return true;
 }
-/** Collect a class expression once per enclosing specialization. Function-local
- * evaluations allocate fresh constructor objects; top-level expressions use
- * immortal templates. Static initialization remains limited to whole top-level
- * initializers, where pendingClassExprInits preserves its evaluation point. */
+/** Collect a class expression once per enclosing specialization. A class
+ * definition the program can EVALUATE more than once (perEvaluationClass:
+ * a function body, a loop body, an instance initializer) allocates fresh
+ * constructor objects, so identity, statics and prototype belong to that
+ * evaluation; definitions evaluated once use immortal templates. Static
+ * initialization remains limited to whole top-level initializers, where
+ * pendingClassExprInits preserves its evaluation point. */
 export function lowerClassExpressionInfo(lowerer, expr) {
     const cached = lowerer.exprClassInfoByName.get(lowerer.classNamer(expr));
     if (cached)
@@ -4907,14 +5085,12 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     if (lowerer.collectingExprClasses.has(expr)) {
         lowerer.unsupported("SC1090", expr, "class expressions whose extends chain re-enters their own collection (a cyclic base through property assignments)");
     }
-    let local = false;
     for (let p = expr.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
         if (ts.isClassStaticBlockDeclaration(p)) {
             lowerer.unsupported("SC1090", expr, "class expressions inside static blocks");
         }
-        if (ts.isFunctionLike(p))
-            local = true;
     }
+    const local = perEvaluationClass(expr);
     if (local &&
         expr.members.nodes.some((member) => member.name && ts.isPrivateIdentifier(member.name)) &&
         !localPrivateFieldsAgree(expr)) {
@@ -5160,7 +5336,15 @@ function lowerClassValue(lowerer, expr, info, binding) {
                         fn: "dyn.classPrototype",
                         args: [
                             boxed,
-                            { kind: "libCall", fn: "dyn.classBasePrototype", args: [baseRef], type: DYN, loc },
+                            info.callableBase.iterator
+                                ? iteratorPrototypeExpr(loc)
+                                : {
+                                    kind: "libCall",
+                                    fn: "dyn.classBasePrototype",
+                                    args: [baseRef],
+                                    type: DYN,
+                                    loc,
+                                },
                         ],
                         type: DYN,
                         loc,
@@ -5539,10 +5723,15 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         if (date)
             return date;
     }
-    if ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, access.name.text)?.field) ||
-        (info.callableBase &&
-            !findStaticOn(lowerer, info, access.name.text) &&
-            !findGenericStaticOn(lowerer, info, access.name.text)))
+    const staticMember = findStaticOn(lowerer, info, access.name.text);
+    // A statically known member that the class value's table does not carry
+    // (a class whose only runtime static is its `Symbol.hasInstance` hook)
+    // calls its own function, as it would without the hook.
+    if ((hasRuntimeStatics(info) &&
+        !access.name.text.startsWith("#") &&
+        !staticMember?.field &&
+        (!staticMember || runtimeStaticDefines(lowerer, info, access.name.text))) ||
+        (info.callableBase && !staticMember && !findGenericStaticOn(lowerer, info, access.name.text)))
         return {
             kind: "dynInvoke",
             recv: lowerer.lowerExprExpecting(access.expression, DYN),
@@ -5730,9 +5919,12 @@ function directRuntimeStaticCall(lowerer, call, access, info, throughValue) {
             c.staticMethods?.has(name) === true ||
             c.genericStatics?.has(name) === true)
             return null;
-        const runtime = c.runtimeStatics?.find((element) => element.name !== undefined &&
-            ts.isIdentifier(element.name) &&
-            element.name.text === name);
+        // A computed name defines the key it folds to, so `static ['m']` in
+        // this class answers for `m` and hides the inherited method.
+        const runtime = c.runtimeStatics?.find((element) => {
+            const elementName = element.name;
+            return elementName !== undefined && classMemberNameOf(lowerer, elementName) === name;
+        });
         if (runtime) {
             if (!ts.isMethodDeclaration(runtime) || !runtime.body)
                 return null;
@@ -5924,9 +6116,16 @@ export function lowerClassValueProperty(lowerer, expr) {
     // its other statics (`Error.stackTraceLimit`) keep their own lowerings.
     if (info?.def.runtime && member !== "name")
         return null;
+    const storedMember = info ? findStaticOn(lowerer, info, member) : undefined;
+    // A statically known member that the class value's table does not carry
+    // (a class whose only runtime static is its `Symbol.hasInstance` hook)
+    // reads its own storage, as it would without the hook.
     if (info &&
-        ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, member)?.field) ||
-            (info.callableBase && !findStaticOn(lowerer, info, member))))
+        ((hasRuntimeStatics(info) &&
+            !member.startsWith("#") &&
+            !storedMember?.field &&
+            (!storedMember || runtimeStaticDefines(lowerer, info, member))) ||
+            (info.callableBase && !storedMember)))
         return {
             kind: "dynKeyGet",
             value: lowerer.lowerExprExpecting(expr.expression, DYN),
@@ -6142,7 +6341,7 @@ function localSubclassesOf(lowerer, base) {
             ts.walkPreorder(sf, (node) => {
                 if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) &&
                     node.heritageClauses !== undefined &&
-                    functionLocalClass(node)) {
+                    perEvaluationClass(node)) {
                     const extended = extendedClassNode(lowerer, node);
                     if (extended) {
                         const list = index.get(extended);
@@ -6768,6 +6967,20 @@ function lowerClassCtorInner(lowerer, info) {
         const thisLocal = lowerer.declareThis(thisType);
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
         const body = [];
+        // A derived constructor that can return a primitive records the pending
+        // TypeError for the construction site to raise. Drop a stale record on
+        // entry: a `finally` that throws after the return abandons the
+        // construction before any site reads it.
+        const pendingPrimitive = constructorPrimitiveFlag(lowerer, info);
+        if (pendingPrimitive !== null) {
+            const clearLoc = locOf(info.ctor ?? info.decl);
+            body.push({
+                kind: "assign",
+                localId: pendingPrimitive.id,
+                value: { kind: "boolLit", value: false, type: BOOL, loc: clearLoc },
+                loc: clearLoc,
+            });
+        }
         // The construction-relevant base: generic families are transparent
         // (an instantiation of a base-less generic class IS a base class —
         // its source has no super()).
@@ -7441,7 +7654,16 @@ function lowerClassMethodBody(lowerer, info, fnLike, fnName, sig) {
             if (shape.mode === "arguments")
                 fnCtx.argumentsLocal = local;
         }
-        const body = [...declared.prologue, ...lowerer.lowerStmts(fnLike.body.statements.nodes)];
+        // See lowerFunction: a generator binds its parameters at the CALL
+        // (FunctionDeclarationInstantiation runs before GeneratorStart) exactly
+        // when that is observable — a destructuring or rest pattern, a default
+        // that evaluates anything, or a body that reads `arguments`.
+        const bindsAtCall = genCh !== null && declared.prologue.length > 0 && generatorParamsBindAtCall(fnLike);
+        const body = [
+            ...declared.prologue,
+            ...(bindsAtCall ? [{ kind: "genBindBarrier", loc: locOf(fnLike) }] : []),
+            ...lowerer.lowerStmts(fnLike.body.statements.nodes),
+        ];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(fnLike));
         const fn = {
             name: fnName,
@@ -7455,7 +7677,7 @@ function lowerClassMethodBody(lowerer, info, fnLike, fnName, sig) {
         if (isAsync)
             fn.async = true;
         if (genCh !== null)
-            fn.generator = genCh;
+            fn.generator = bindsAtCall ? { ...genCh, bindAtCall: true } : genCh;
         return fn;
     }
     finally {
@@ -7501,7 +7723,14 @@ export function lowerStaticMethod(lowerer, info, name) {
             declared.params.push({ localId: local.id, name: "%arguments", type: DYN });
             fnCtx.argumentsLocal = local;
         }
-        const body = [...declared.prologue, ...lowerer.lowerStmts(entry.member.body.statements.nodes)];
+        // See lowerFunction: a generator binds its parameters at the CALL
+        // exactly when that is observable.
+        const bindsAtCall = genCh !== null && declared.prologue.length > 0 && generatorParamsBindAtCall(entry.member);
+        const body = [
+            ...declared.prologue,
+            ...(bindsAtCall ? [{ kind: "genBindBarrier", loc: locOf(entry.member) }] : []),
+            ...lowerer.lowerStmts(entry.member.body.statements.nodes),
+        ];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(entry.member));
         const fn = {
             name: `%${info.def.name}.static:${name}`,
@@ -7514,7 +7743,7 @@ export function lowerStaticMethod(lowerer, info, name) {
         if (isAsync)
             fn.async = true;
         if (genCh !== null)
-            fn.generator = genCh;
+            fn.generator = bindsAtCall ? { ...genCh, bindAtCall: true } : genCh;
         return fn;
     }
     catch (e) {
@@ -7919,6 +8148,10 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         return dateSuperCall(thisRef, info, args[0], loc);
     if (info.extendsArray)
         return arraySuperCall(info, thisRef, args[0], loc);
+    // super() into %Iterator%: NewTarget is the subclass, so the abstract
+    // constructor only creates the receiver the derived constructor made.
+    if (info.callableBase?.iterator)
+        return { kind: "exprStmt", expr: args[0], loc };
     if (info.callableBase)
         return {
             kind: "exprStmt",
@@ -8473,6 +8706,20 @@ function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
         loc,
     });
 }
+/** The supported map layout a contextual type pins for `new Map()`: the type
+ * itself, or the single map arm of a union — a nullable annotation such as
+ * `Map<K, V> | undefined`, or `ReadonlyMap<K, V> | undefined`, where a Map
+ * value can only inhabit the map arm and the no-argument constructor gives
+ * the checker nothing to infer the type arguments from. */
+function contextualMapLayout(lowerer, ctx) {
+    const mapped = lowerer.mapTypeOf(ctx);
+    if (mapped?.kind === "map")
+        return mapped;
+    if (mapped?.kind !== "union")
+        return null;
+    const arms = (lowerer.unions.get(mapped.unionId)?.arms ?? []).filter((arm) => arm.kind === "map");
+    return arms.length === 1 ? arms[0] : null;
+}
 function assignedThisFieldType(lowerer, expr) {
     const parent = expr.parent;
     if (!ts.isBinaryExpression(parent) ||
@@ -8537,13 +8784,162 @@ function checkedElementConstruction(lowerer, info, narrowed, args, loc) {
         loc,
     };
 }
+/** `new x.someLibMethod(...)`: a built-in method is not a constructor.
+ * Node evaluates the receiver, reads the member, evaluates the arguments,
+ * then throws `TypeError: <callee> is not a constructor` (V8 prints an
+ * anonymous intermediate value as `(intermediate value)`). On a typed
+ * receiver and on %Iterator.prototype% the member is the built-in method.
+ * Any other checked-dynamic receiver may hold any value: the read throws
+ * Node's TypeError for undefined and null before any argument evaluates
+ * and runs an accessor, and a function it answers constructs as for any
+ * dynamic callee. Null otherwise. */
+function lowerNonConstructorNew(lowerer, expr) {
+    let callee = expr.expression;
+    while (ts.isParenthesizedExpression(callee))
+        callee = callee.expression;
+    if (!ts.isPropertyAccessExpression(callee) || callee.questionDotToken)
+        return null;
+    if (!lowerer.isStdlibMember(callee))
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(callee.name);
+    const method = symbol?.declarations?.some((decl) => ts.isMethodSignatureDeclaration(decl) || ts.isMethodDeclaration(decl));
+    if (!method)
+        return null;
+    const args = expr.arguments?.nodes ?? [];
+    if (args.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(expr);
+    let receiver = callee.expression;
+    while (ts.isParenthesizedExpression(receiver))
+        receiver = receiver.expression;
+    const left = ts.isClassExpression(receiver) ||
+        ts.isFunctionExpression(receiver) ||
+        ts.isArrowFunction(receiver)
+        ? "(intermediate value)"
+        : ts.getTextOfNode(receiver);
+    const message = `${left}.${callee.name.text} is not a constructor`;
+    const recv = lowerer.lowerExpr(receiver);
+    // %Iterator.prototype% (scr_js_iterator.c) holds the runtime's helpers.
+    const intrinsic = recv.kind === "libCall" && recv.fn === "iterator.prototype";
+    if (intrinsic || (recv.type.kind !== "dyn" && recv.type.kind !== "union")) {
+        const stmts = [
+            { kind: "exprStmt", expr: recv, loc: locOf(receiver) },
+            ...args.map((arg) => ({
+                kind: "exprStmt",
+                expr: lowerer.lowerExpr(arg),
+                loc: locOf(arg),
+            })),
+        ];
+        return {
+            kind: "seqExpr",
+            stmts,
+            result: nodeThrowExpr(1, "", message, DYN, loc),
+            type: DYN,
+            loc,
+        };
+    }
+    const member = lowerer.declareHiddenLocal("%newMember", DYN);
+    const stmts = [
+        {
+            kind: "varDecl",
+            localId: member.id,
+            init: {
+                kind: "dynKeyGet",
+                key: strLit(callee.name.text, loc),
+                value: lowerer.coerceToExpected(recv, DYN),
+                type: DYN,
+                loc: locOf(callee),
+            },
+            loc: locOf(callee),
+        },
+    ];
+    const argRefs = args.map((arg) => {
+        const local = lowerer.declareHiddenLocal("%newArg", DYN);
+        stmts.push({
+            kind: "varDecl",
+            localId: local.id,
+            init: lowerer.coerceToExpected(lowerer.lowerExpr(arg), DYN),
+            loc: locOf(arg),
+        });
+        return varRef(local.id, DYN, loc);
+    });
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: {
+            kind: "ternary",
+            cond: {
+                kind: "dynTest",
+                test: "function",
+                value: varRef(member.id, DYN, loc),
+                type: BOOL,
+                loc,
+            },
+            then: checkedClassConstruction(lowerer, varRef(member.id, DYN, loc), argRefs, loc, `${left}.${callee.name.text}`),
+            else_: nodeThrowExpr(1, "", message, DYN, loc),
+            type: DYN,
+            loc,
+        },
+        type: DYN,
+        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) {
     return ref?.kind === "collection" || ref?.kind === "error";
 }
+/** `new url.URL(...)` / `new url.URLSearchParams(...)`: the member of a
+ * node:url binding (a namespace import, a require result, or an import=
+ * alias) resolves to the stdlib class symbol the named import binds, so the
+ * construction takes the same lowering. A binding that holds the class
+ * (`const U = url.URL`) follows its initializer to the same symbol. */
+function stdlibUrlClassOf(lowerer, callee) {
+    const classNamed = (sym) => {
+        if (!sym || !lowerer.isStdlibSymbol(sym))
+            return null;
+        const name = ts.symbolName(sym);
+        return name === "URL" || name === "URLSearchParams" ? name : null;
+    };
+    const aliased = (raw) => raw && raw.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(raw) : raw;
+    let selected = callee;
+    for (let hops = 0; hops < 4; hops++) {
+        while (ts.isParenthesizedExpression(selected))
+            selected = selected.expression;
+        if (ts.isPropertyAccessExpression(selected) && !selected.questionDotToken) {
+            return classNamed(aliased(lowerer.checker.getSymbolAtLocation(selected.name)));
+        }
+        if (!ts.isIdentifier(selected))
+            return null;
+        const sym = aliased(lowerer.checker.getSymbolAtLocation(selected));
+        if (!sym)
+            return null;
+        const known = classNamed(sym);
+        if (known !== null)
+            return known;
+        const decl = sym.valueDeclaration;
+        if (!decl || !ts.isVariableDeclaration(decl) || !decl.initializer)
+            return null;
+        let next = decl.initializer;
+        while (ts.isParenthesizedExpression(next))
+            next = next.expression;
+        if (next === selected)
+            return null;
+        selected = next;
+    }
+    return null;
+}
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    // Constructing a Node 24 global the native runtime does not provide
+    // (WebSocket, FormData, …): the value a read answers refuses construction
+    // (host-global-values.ts), so the construction is that refusal — SC2020,
+    // which a JavaScript source defers to the throw at this statement.
+    {
+        const hostGlobal = hostGlobalNameOfRead(lowerer, expr.expression);
+        if (hostGlobal !== null)
+            lowerer.hostGlobalFence(hostGlobal, expr.expression);
+    }
     // The deprecated `new Buffer(...)` (containers/bytes.ts).
     {
         const buffer = lowerBufferConstruct(lowerer, expr);
@@ -8571,6 +8967,25 @@ export function lowerNew(lowerer, expr) {
             return lowerWithInlineRequireInit(lowerer, req, () => lowerNew(lowerer, expr));
         }
     }
+    // `new url.URL(input)` / `new url.URLSearchParams(init?)`: the node:url
+    // member names the same class the named import does, so both take the
+    // class's own lowering (including its argument diagnostics).
+    {
+        const urlClass = stdlibUrlClassOf(lowerer, expr.expression);
+        if (urlClass === "URL")
+            return lowerUrlNew(lowerer, expr);
+        if (urlClass === "URLSearchParams")
+            return lowerSearchParamsNew(lowerer, expr, loc);
+    }
+    const wrapper = lowerWrapperNew(lowerer, expr);
+    if (wrapper)
+        return wrapper;
+    const abstractIterator = lowerIteratorNew(lowerer, expr);
+    if (abstractIterator)
+        return abstractIterator;
+    const nonConstructor = lowerNonConstructorNew(lowerer, expr);
+    if (nonConstructor)
+        return nonConstructor;
     const worker = lowerWorkerNew(lowerer, expr);
     if (worker)
         return worker;
@@ -8644,7 +9059,15 @@ export function lowerNew(lowerer, expr) {
         expr.expression.name.text === "Segmenter" &&
         lowerer.isStdlibGlobal(expr.expression.expression, "Intl")) {
         const args = expr.arguments?.nodes ?? [];
-        const undefinedArg = (arg) => (lowerer.typeOf(arg).flags & ts.TypeFlags.Undefined) !== 0;
+        // An argument whose value IS undefined: exactly undefined, or void. A
+        // union that merely includes undefined may hold a locale or an options
+        // object at run time, and the constructor cannot inspect either — such
+        // an argument is refused below rather than silently read as the default
+        // locale or the default options.
+        const undefinedArg = (arg) => {
+            const flags = lowerer.typeOf(arg).flags;
+            return flags === ts.TypeFlags.Undefined || flags === ts.TypeFlags.Void;
+        };
         // 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
@@ -8654,27 +9077,28 @@ export function lowerNew(lowerer, expr) {
         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.
+        // Word segmentation lowers through ICU (scr_intl.c). Sentence
+        // segmentation does not: JavaScript dependencies may construct sentence
+        // segmenters they use only on some paths, so 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"];
+            : ["grapheme", "word"];
         const options = args[1];
         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');
+                lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options, { granularity: "grapheme" } and { granularity: "word" }; sentence segmentation remains 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');
+                    lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options, { granularity: "grapheme" } and { granularity: "word" }; sentence segmentation remains unsupported');
                 }
                 granularity = property.initializer.text;
             }
@@ -8688,12 +9112,28 @@ export function lowerNew(lowerer, expr) {
                 loc: locOf(arg),
             };
         });
+        // Grapheme segmentation is the engine-free table-driven segmenter
+        // (scr_grapheme.c). NOTE: once ICU is established everywhere, this fast
+        // path is deleted in favor of ICU's character iterator (design I4).
         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") {
+        if (granularity === "word") {
+            // ICU's word iterator at the requested locale; a literal language tag
+            // is the locale, and the empty string means the default locale (what
+            // Node negotiates when the argument is absent or undefined).
+            const tag = args[0] !== undefined && ts.isStringLiteralLike(args[0]) ? args[0].text : "";
+            result = {
+                kind: "libCall",
+                fn: "icu.segmenterWord",
+                args: [strLit(tag, loc)],
+                type: DYN,
+                loc,
+            };
+        }
+        // A sentence segmenter carries its segment() refusal, which coverage
+        // lists as deferred to runtime.
+        if (granularity === "sentence") {
             const surface = `Intl.Segmenter segmentation with granularity '${granularity}'`;
-            lowerer.runtimeFences.push(noLoweringDiag(surface, loc, "only grapheme segmenters segment; word and sentence segmenters construct"));
+            lowerer.runtimeFences.push(noLoweringDiag(surface, loc, "only grapheme and word segmenters segment; 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 = {
@@ -9066,7 +9506,21 @@ export function lowerNew(lowerer, expr) {
             if (args.some(ts.isSpreadElement))
                 lowerer.noLowering("new RegExp with spread arguments", expr);
             const values = args.map((arg) => lowerer.lowerExpr(arg));
-            if (values.some((value) => value.type.kind === "dyn" || value.type.kind === "regex")) {
+            // The statically spelled form below needs a string or undefined in
+            // each slot. Every other value — a `dyn` or `regex` argument, and
+            // any primitive or object the static form cannot spell, such as a
+            // boolean, number or null flags argument — reaches the runtime's
+            // JavaScript ToString, exactly the coercion the spec's RegExp
+            // builtin performs, so an invalid flags string throws Node's
+            // SyntaxError at construction instead of refusing the build.
+            const stringSlot = (value) => value.type.kind === "string" ||
+                value.type.kind === "undefinedT" ||
+                (value.type.kind === "union" &&
+                    (lowerer.unions
+                        .get(value.type.unionId)
+                        ?.arms.every((arm) => arm.kind === "string" || arm.kind === "undefinedT") ??
+                        false));
+            if (values.some((value) => value.type.kind === "dyn" || value.type.kind === "regex" || !stringSlot(value))) {
                 const checked = [0, 1].map((index) => values[index]
                     ? lowerer.coerceInto(args[index], values[index], DYN)
                     : dynUndefinedExpr(loc));
@@ -9078,7 +9532,9 @@ export function lowerNew(lowerer, expr) {
                     loc,
                 };
             }
-            const strArg = (a, what) => {
+            // Every slot reaches here as a string or a nullish cover of one: the
+            // checked path above took every other value.
+            const strArg = (a) => {
                 if (!a)
                     return { kind: "strLit", value: "", type: STRING, loc };
                 const v = values[args.indexOf(a)];
@@ -9094,19 +9550,13 @@ export function lowerNew(lowerer, expr) {
                         loc,
                     };
                 }
-                if (v.type.kind === "union" &&
-                    lowerer.unions
-                        .get(v.type.unionId)
-                        ?.arms.every((arm) => arm.kind === "string" || arm.kind === "undefinedT")) {
+                if (v.type.kind === "union") {
                     return { kind: "nullish", left: v, right: empty, type: STRING, loc: locOf(a) };
                 }
-                if (v.type.kind !== "string") {
-                    lowerer.noLowering(`new RegExp with a '${lowerer.fmt(v.type)}' ${what}`, a, "string or undefined arguments are the lowered form (a RegExp copy or ToString coercion has no lowering)");
-                }
                 return v;
             };
-            const pattern = strArg(args[0], "pattern");
-            const flags = strArg(args[1], "flags argument");
+            const pattern = strArg(args[0]);
+            const flags = strArg(args[1]);
             // Node accepts the 'd' flag the engine does not have; a literal
             // flags string refuses here like the literal regex form.
             if (flags.kind === "strLit" && args[1] !== undefined && flags.value.includes("d")) {
@@ -9234,8 +9684,9 @@ export function lowerNew(lowerer, expr) {
         // starting at 0 (nothing buffered). A literal Buffer encoding folds
         // its alias at compile time; any other encoding argument is
         // normalized at run time (Node's normalizeEncoding, which throws
-        // ERR_UNKNOWN_ENCODING for an unknown name). Omitted means utf8,
-        // Node's default.
+        // ERR_UNKNOWN_ENCODING for an unknown name). An encoding that may not
+        // be a string takes strdec.encodingValue, which formats the error
+        // with %s. Omitted means utf8, Node's default.
         if (symbol && ts.symbolName(symbol) === "StringDecoder" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments?.nodes ?? [];
             if (args.length > 1) {
@@ -9248,11 +9699,16 @@ export function lowerNew(lowerer, expr) {
                 : encT.isStringLiteralType()
                     ? knownBufEncoding(encT.value)
                     : undefined;
+            const textual = (type) => type.isUnionType()
+                ? ts.constituentTypes(type).every(textual)
+                : (type.flags &
+                    (ts.TypeFlags.StringLike | ts.TypeFlags.Undefined | ts.TypeFlags.Null)) !==
+                    0;
             const encoding = encName !== undefined
                 ? { kind: "strLit", value: encName, type: STRING, loc }
                 : {
                     kind: "libCall",
-                    fn: "strdec.encoding",
+                    fn: textual(encT) ? "strdec.encoding" : "strdec.encodingValue",
                     args: [lowerer.lowerExprExpecting(encNode, DYN)],
                     type: STRING,
                     loc,
@@ -9357,10 +9813,10 @@ export function lowerNew(lowerer, expr) {
             }
             else if (mapped?.kind !== "map" || contextualSeed) {
                 const ctx = lowerer.checker.getContextualType(expr);
-                const ctxMapped = ctx ? lowerer.mapTypeOf(ctx) : null;
-                if (ctx && ctxMapped?.kind === "map") {
+                const ctxMap = ctx ? contextualMapLayout(lowerer, ctx) : null;
+                if (ctx && ctxMap !== null) {
                     tsType = ctx;
-                    mapped = ctxMapped;
+                    mapped = ctxMap;
                 }
             }
             // `new Map(source)` the checker types `Map<any, any>` because the
@@ -9632,7 +10088,16 @@ export function lowerNew(lowerer, expr) {
         // TextEncoder, ...) typechecks and reports SC2020 here. The named
         // families carry pointed hints: each states WHY no honest static
         // lowering exists (or what to use instead).
-        if (lowerer.isStdlibSymbol(symbol ?? undefined)) {
+        // `new BigInt64Array(...)` / `new BigUint64Array(...)` are exempt where
+        // the checked-dynamic tier exists: the typed IR has no BigInt element
+        // kind, so these construct through the typed-array constructor VALUE
+        // (the checked-construction fallback below, whose runtime build reads and
+        // stores BigInt elements). Static code keeps the refusal.
+        const bigintBytesCtor = ts.isIdentifier(identifier) &&
+            symbol != null &&
+            BIGINT_BYTES_NAMES.has(ts.symbolName(symbol)) &&
+            isJsSourceFile(ts.getSourceFileOfNode(expr));
+        if (!bigintBytesCtor && lowerer.isStdlibSymbol(symbol ?? undefined)) {
             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)",
@@ -9873,6 +10338,31 @@ export function lowerNew(lowerer, expr) {
     }
     // Checked construction supports emitted classes and builtin typed arrays.
     const callee = tryLowerExpression(lowerer, expr.expression);
+    // A callee whose VALUE is a primitive (`new (null)()`, `new (5)()`, and a
+    // union whose arms are all primitives): JavaScript's IsConstructor step
+    // throws Node's TypeError, which names the constructed expression. V8
+    // evaluates the callee, then every argument, and only then checks, so the
+    // arguments lower for their effects ahead of the throw.
+    if (callee &&
+        isPrimitiveValueType(callee.type) &&
+        !isBuiltinIdentityToken(lowerer, expr.expression, callee)) {
+        return primitiveCalleeThrow(lowerer, expr, callee, loc);
+    }
+    if (callee && callee.type.kind === "union") {
+        const arms = lowerer.unions.get(callee.type.unionId)?.arms ?? [];
+        if (arms.length > 0 && arms.every(isPrimitiveValueType)) {
+            return primitiveCalleeThrow(lowerer, expr, callee, loc);
+        }
+    }
+    // A callee the CHECKER types as a primitive that still lowers to a
+    // dynamic slot (`const n = null`, or a property whose initializer was
+    // null): the same Node TypeError, but the value decides at run time,
+    // because a JavaScript property keeps its initializer's type through a
+    // later assignment (`reg.ctor = Foo; new reg.ctor()`). A typed
+    // construction site and an `any` callee keep the lowering they had.
+    if (callee && callee.type.kind === "dyn" && staticallyPrimitive(lowerer, expr.expression)) {
+        return primitiveCheckedNew(lowerer, expr, callee, loc);
+    }
     if (callee &&
         (callee.type.kind === "dyn" ||
             ((callee.type.kind === "func" || callee.type.kind === "classval") &&
@@ -9899,6 +10389,57 @@ function lowerCheckedConstructor(lowerer, expr, callee) {
     }
     return checkedClassConstruction(lowerer, callee, args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
 }
+/** A checker-primitive callee whose value is a dynamic slot: the callee and
+ * every argument evaluate, then the runtime primitive check throws Node's
+ * "<callee> is not a constructor" — or, when the slot holds something else
+ * after all, constructs it as a dynamic `new` always did. */
+function primitiveCheckedNew(lowerer, expr, callee, loc) {
+    const message = `${constructorSpelling(expr.expression)} is not a constructor`;
+    const args = expr.arguments?.nodes ?? [];
+    if (args.some(ts.isSpreadElement)) {
+        const packed = lowerer.completeArgs(args, [{ type: DYN, mode: "dynRest" }], loc, expr)[0];
+        return primitiveCheckedConstruction(lowerer, callee, message, [], loc, packed);
+    }
+    return primitiveCheckedConstruction(lowerer, callee, message, args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
+}
+/** The always-throwing construction of a provably primitive callee. */
+function primitiveCalleeThrow(lowerer, expr, callee, loc) {
+    const args = expr.arguments?.nodes ?? [];
+    const effects = [callee];
+    if (args.some(ts.isSpreadElement)) {
+        effects.push(lowerer.completeArgs(args, [{ type: DYN, mode: "dynRest" }], loc, expr)[0]);
+    }
+    else {
+        for (const arg of args)
+            effects.push(lowerer.lowerExpr(arg));
+    }
+    return throwAfterEach(effects, throwTypeError(strLit(`${constructorSpelling(expr.expression)} is not a constructor`, loc), DYN, loc), loc);
+}
+/** The constructed expression as V8 names it in "is not a constructor": its
+ * source text, without the parentheses that only group it (`new (null)()`
+ * reports "null is not a constructor") and with a call's argument list
+ * abbreviated to "..." (`new (factory(null))()` reports "factory(...)",
+ * `new (factory(o).f)()` "factory(...).f", `new o["f"]()` "o.f"). A comma
+ * expression keeps V8's own "(a , b)" spelling. */
+function constructorSpelling(node) {
+    let spelled = node;
+    while (ts.isParenthesizedExpression(spelled))
+        spelled = spelled.expression;
+    if (ts.isCallExpression(spelled))
+        return `${constructorSpelling(spelled.expression)}(...)`;
+    if (ts.isPropertyAccessExpression(spelled)) {
+        return `${constructorSpelling(spelled.expression)}.${spelled.name.text}`;
+    }
+    if (ts.isElementAccessExpression(spelled) &&
+        ts.isStringLiteralLike(spelled.argumentExpression) &&
+        /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(spelled.argumentExpression.text)) {
+        return `${constructorSpelling(spelled.expression)}.${spelled.argumentExpression.text}`;
+    }
+    if (ts.isBinaryExpression(spelled) && spelled.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+        return `(${constructorSpelling(spelled.left)} , ${constructorSpelling(spelled.right)})`;
+    }
+    return spelled.getText();
+}
 /** A getter/setter invocation over an accessor target's receiver — the
  * same whole-program devirtualization as method calls: a virtualCall
  * when some strict subclass of the receiver's static class overrides