@scriptc/compiler 0.2.0 → 0.2.1

package/dist/frontend/lowering/lowerer.js

@@ -1,3 +1,4 @@
+import { pathModuleValue } from "./lower-builtin-values.js";
 import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
 import { sanitizeUnregisteredClassTypes } from "./sanitize-class-types.js";
@@ -29,7 +30,7 @@ import { bindingSource } from "../binding-source.js";
 import { tsgoPath } from "../dts-paths.js";
 import * as ts from "../ts7/adapter.js";
 import { literalValues } from "../literal-values.js";
-import { literalUnionArm } from "../union-discriminants.js";
+import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
 import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.js";
 import {} from "../npm.js";
@@ -50,7 +51,7 @@ import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string
 import { lowerStreamModuleCall } from "./lower-stream.js";
 import { lowerEmitOverrideSpec } from "./lower-event-emitter.js";
 import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleOf, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerNodeModuleCall, lowerTimersPromisesSetInterval, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecFileCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, registerPromisifiedBuiltinDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerCryptoModuleCall, lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
-import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerAbortControllerNew, lowerDynamicHeadersIteratorCall, lowerDynamicHeadersSpread, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
+import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerAbortControllerNew, lowerDynamicHeadersIteratorCall, lowerDynamicHeadersSpread, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty } from "./lower-test.js";
@@ -514,6 +515,14 @@ export function dynFallbackType(lowerer, node, t) {
     if (!isJsSourceFile(node.getSourceFile())) {
         if (t.flags & ts.TypeFlags.Any)
             return DYN;
+        const symbol = t.getSymbol();
+        const args = symbol && lowerer.isStdlibSymbol(symbol) ? lowerer.checker.getTypeArguments(t) : [];
+        if (symbol?.name === "Promise" && args[0] && args[0].flags & ts.TypeFlags.Any)
+            return jsFallbackPromiseType(lowerer, t);
+        if (symbol && ["Generator", "AsyncGenerator", "IterableIterator"].includes(symbol.name) && args.some((arg) => arg.flags & ts.TypeFlags.Any))
+            return jsFallbackGeneratorType(lowerer, t);
+        if (lowerer.checker.isArrayType(t) && ((lowerer.checker.getTypeArguments(t)[0]?.flags ?? 0) & ts.TypeFlags.Any) !== 0)
+            return DYN;
         // TS single-call-signature function types: per-piece fallback, but
         // ONLY `any` pieces fall to dyn — any other unmappable piece keeps
         // the whole type's own fence.
@@ -765,6 +774,9 @@ export function jsFuncNameOf(node) {
         if (p && ts.isVariableDeclaration(p) && p.initializer === n && ts.isIdentifier(p.name)) {
             return p.name.text;
         }
+        if (p && ts.isBindingElement(p) && p.initializer === n && ts.isIdentifier(p.name)) {
+            return p.name.text;
+        }
         if (p && ts.isPropertyAssignment(p) && p.initializer === n && ts.isIdentifier(p.name)) {
             return p.name.text;
         }
@@ -1331,6 +1343,15 @@ export class Lowerer {
     /** Union re-tag helpers (%union.retag.N), interned per (from, to)
      * unionId pair — see unionRetagHelper. */
     retagHelpers = new Map();
+    /** Copy-only routes depend on the two union contracts and discriminator
+     * layouts, without recursive width assumptions or evolving class members. */
+    copyRetagHelpers = new Map();
+    unionLiteralOwners = new Map();
+    strippedUndefinedArms = new Map();
+    stdlibSymbols = new Map();
+    /** Method adapter names are owned by class-method-values. Looking them
+     * up must not scan and retain every unrelated lifted function. */
+    classMethodValueHelpers = new Set();
     /** Callee names of every interned coercion helper whose CALL mints a
      * FRESH closure per evaluation (%fn.width.*, %fn.adapt.*,
      * %fnval.spawnres.*). Registered at the mint site — NOT recovered by
@@ -1415,6 +1436,9 @@ export class Lowerer {
     /** Keyed by program-wide qualified class name (what IR object types carry). */
     classes = new Map();
     classBySymbol = new Map();
+    /** Named method slots observed before class collection need a callable
+     * ABI and shared prototype descriptors instead of call-site specialization. */
+    prototypeMethodAccesses = new Map();
     /** Inferred JS methods participating in an override chain keep a vtable
      * ABI instead of call-site specialization. Filled before class collection. */
     virtualJsMethods = new Set();
@@ -1566,7 +1590,10 @@ export class Lowerer {
     /** One Error-method helper belongs to this lowering session. Its cached
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision = null;
+    errorPropertyDispatchRevision = null;
     lambdaCounter = 0;
+    preparedClassFactories = new Map();
+    preparingClassFactories = new Set();
     /** Statement lists currently mid-lowering, innermost last: the forward-
      * capture machinery needs to know which later statements of an OPEN list
      * a symbol's declaration sits in, which scope frame list-level declarations
@@ -1703,6 +1730,27 @@ export class Lowerer {
                 ? { kind: "object", className: this.mixinTypeContext.className }
                 : null,
             localClassInstance: (decl) => {
+                // Computed heritage can close over parameters of its factory.
+                // A speculative checker query outside that factory must not lower
+                // the extends expression in the caller's lexical scope.
+                if (!this.classes.has(this.classNamer(decl)) && !this.collectingExprClasses.has(decl) &&
+                    decl.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types.some((base) => {
+                        const expression = base.expression;
+                        if (ts.isCallExpression(expression))
+                            return true;
+                        if (ts.isIdentifier(expression) && this.isStdlibGlobal(expression, expression.text))
+                            return false;
+                        const symbol = this.checker.getSymbolAtLocation(ts.isPropertyAccessExpression(expression) ? expression.name : expression);
+                        const resolved = symbol && symbol.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(symbol) : symbol;
+                        if (ts.isPropertyAccessExpression(expression) && this.isStdlibGlobal(expression.expression, "globalThis") &&
+                            this.builtinErrorInfoOf(resolved))
+                            return false;
+                        if (resolved && this.classBySymbol.has(resolved))
+                            return false;
+                        const mapped = this.mapTypeOf(this.typeOf(expression));
+                        return mapped?.kind !== "classval" || !this.classes.has(mapped.className);
+                    })))
+                    return null;
                 for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
                     if (!ts.isFunctionDeclaration(parent) && !ts.isFunctionExpression(parent) &&
                         !ts.isArrowFunction(parent) && !ts.isMethodDeclaration(parent))
@@ -2266,7 +2314,7 @@ export class Lowerer {
             return null;
         const directSpec = requireSpecOf(decl.initializer);
         if (directSpec !== null) {
-            return resolveImport(this.program, decl.getSourceFile(), directSpec) ??
+            return resolveImport(this.program, decl.getSourceFile(), directSpec, "require") ??
                 npmStaticDepSf7(this.program, decl.getSourceFile(), directSpec, "require");
         }
         return createRequireProgramModuleOf(this, decl.initializer)?.dep ?? null;
@@ -2586,7 +2634,7 @@ export class Lowerer {
         // Without the guarded %init call at this position
         // those globals stay uninitialized: the dep's module body would never
         // run.
-        const dep = resolveImport(this.program, node.getSourceFile(), spec) ??
+        const dep = resolveImport(this.program, node.getSourceFile(), spec, "require") ??
             npmStaticDepSf7(this.program, node.getSourceFile(), spec, "require");
         if (!dep || dep.fileName.endsWith(".json"))
             return null;
@@ -3832,6 +3880,8 @@ export class Lowerer {
         // before collectProgram visits them one by one; reached body lowering
         // will reuse the same answers later.
         this.prefetchClassCollection(parts.flatMap((fp) => fp.classDecls));
+        const collectionEdges = new Set();
+        this.onEdge = (name) => { collectionEdges.add(name); };
         this.collectProgram(parts);
         this.analyzeRuntimeOptionalArrayReads(parts);
         // Decorated classes analyze post-collection here too: the %init seeds
@@ -3894,13 +3944,13 @@ export class Lowerer {
                 units.set(`%${cName}.constructor`, {
                     order: unitOrder++,
                     roots: classCtorRoots(info),
-                    lower: () => this.lowerClassCtor(info),
+                    lower: () => info.localClass && !info.localClass.ready ? null : this.lowerClassCtor(info),
                 });
                 for (const { mName, member } of this.classMethodMembers(info)) {
                     units.set(`%${cName}.${mName}`, {
                         order: unitOrder++,
                         roots: functionRoots(member),
-                        lower: () => this.lowerClassMethodMember(info, member),
+                        lower: () => info.localClass && !info.localClass.ready ? null : this.lowerClassMethodMember(info, member),
                     });
                 }
                 for (const prop of info.throwingSetters) {
@@ -3996,11 +4046,13 @@ export class Lowerer {
             const cName = info.def.name;
             const register = (name, roots, lower) => {
                 units.set(name, { order: unitOrder++, roots, lower });
+                if (reachable.has(name))
+                    queue.push(name);
                 metadataPriority.set(name, [3, expressionMetadataOrder++]);
             };
-            register(`%${cName}.constructor`, classCtorRoots(info), () => this.lowerClassCtor(info));
+            register(`%${cName}.constructor`, classCtorRoots(info), () => info.localClass && !info.localClass.ready ? null : this.lowerClassCtor(info));
             for (const { mName, member } of this.classMethodMembers(info)) {
-                register(`%${cName}.${mName}`, functionRoots(member), () => this.lowerClassMethodMember(info, member));
+                register(`%${cName}.${mName}`, functionRoots(member), () => info.localClass && !info.localClass.ready ? null : this.lowerClassMethodMember(info, member));
             }
             if (info.staticMethods)
                 for (const [name, entry] of info.staticMethods) {
@@ -4010,6 +4062,8 @@ export class Lowerer {
                 register(`%${cName}.set:${prop}`, [], () => this.throwingSetterFn(info, prop));
             }
         };
+        for (const name of collectionEdges)
+            this.onEdge(name);
         // Generic instances queued by the bodies above lower here (an instance
         // body fires edges of its own and can queue further instances of
         // either kind — function instances and class instantiations drain to
@@ -4477,7 +4531,7 @@ export class Lowerer {
                 Segmenter: intlHint,
                 DisplayNames: intlHint,
                 TextEncoder: "TextEncoder instances support encode(string) and encode(); other codec operations require a dedicated lowering",
-                TextDecoder: "TextDecoder instances support recognized literal labels with default options and whole-buffer decode(Uint8Array); runtime labels and options remain unsupported",
+                TextDecoder: "TextDecoder instances support recognized labels, fatal/ignoreBOM option literals, and streaming UTF-8/UTF-16/single-byte decode; runtime option objects remain unsupported",
             };
             this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node), typeHints[stdlibOwnSym?.name ?? ""]));
             throw new PoisonError();
@@ -4533,6 +4587,12 @@ export class Lowerer {
         return fenceStaticReadableStreamMember(this, access, use);
     }
     typeOf(node) {
+        // A checked JS method receives its actual call-site receiver. Its
+        // declaration's inferred class type must not turn property reads back
+        // into native field loads when the method is borrowed by another object.
+        if (node.kind === ts.SyntaxKind.ThisKeyword && isJsSourceFile(node.getSourceFile()) &&
+            this.fnStack.length > 0 && this.resolveThis()?.type.kind === "dyn")
+            return this.checker.getUnknownType();
         // Inside an optional-chain body the guarded receiver is typed by its
         // NON-NULLISH type (the chain's tag test proved it), so every
         // receiver-kind check downstream sees the narrowed arm.
@@ -4887,8 +4947,20 @@ export class Lowerer {
      * this is THE tag for that (union, arm) pair program-wide — every wrap,
      * narrow, and tag test agrees by construction. */
     armTag(unionId, arm) {
+        return this.unions.armTag(unionId, arm);
+    }
+    /** Literal ownership depends only on the union contract and record layouts.
+     * Recheck it when recursive placeholders close, not for every literal. */
+    literalUnionArm(unionId, values) {
         const def = this.unions.get(unionId);
-        return def ? def.arms.findIndex((a) => typeEquals(a, arm)) : -1;
+        if (!def || values.length === 0)
+            return null;
+        let cached = this.unionLiteralOwners.get(unionId);
+        if (!cached || cached.shapes !== this.shapes.revision || cached.unions !== this.unions.revision) {
+            cached = { owners: discriminantOwners(def, (id) => this.shapes.get(id)), shapes: this.shapes.revision, unions: this.unions.revision };
+            this.unionLiteralOwners.set(unionId, cached);
+        }
+        return literalUnionArm(def, values, (id) => this.shapes.get(id), cached.owners);
     }
     /** Implicit union construction. Wherever a value flows into a typed slot
      * (initializer, assignment, call argument, return, field write, record
@@ -5009,23 +5081,22 @@ export class Lowerer {
                 return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr, loc: expr.loc }],
                     result: dynUndefinedExpr(expr.loc), type: DYN, loc: expr.loc };
             }
-            // An error-HIERARCHY object (builtin subclass or user `extends
-            // Error` class) upcasts to the %Error root first — the caughtToDyn
-            // encoding (scr_dyn_from_error) carries name/message/code and the
-            // runtime CACHES the identity edge, so `instanceof TypeError` on
-            // the dyn side still answers exactly (dyn.errInstanceof). Only the
-            // root spelling was convertible before; the harness passes typed
-            // errors into untyped helpers constantly.
+            // Preserve the concrete class so checked property/method dispatch
+            // discovers user Error subclasses. Runtime boxing selects the live
+            // view by vtable even when an error first crosses through its base.
             if (expr.type.kind === "object" && this.errorHierarchyClassOf(expr.type.className)) {
                 return {
                     kind: "dynFrom",
-                    value: this.upcastTo(expr, "%Error"),
+                    value: expr,
                     type: DYN,
                     loc: expr.loc,
                 };
             }
             if (expr.kind === "unitLit" || this.dynConvertible(expr.type)) {
-                return { kind: "dynFrom", value: expr, type: DYN, loc: expr.loc };
+                const shape = expr.type.kind === "record" ? this.shapes.get(expr.type.shapeId) : undefined;
+                const liveRef = expr.type.kind === "array" || !!shape && (shape.fields.length > 0 || shape.indexValue !== undefined);
+                return { kind: "dynFrom", value: expr, type: DYN, loc: expr.loc,
+                    ...(liveRef ? { liveRef: true } : {}) };
             }
             return expr;
         }
@@ -5447,6 +5518,7 @@ export class Lowerer {
                     return;
                 const sameFamily = (src.kind === "record" && arm.kind === "record") ||
                     (src.kind === "array" && arm.kind === "array") ||
+                    (src.kind === "func" && arm.kind === "func") ||
                     (src.kind === "object" && arm.kind === "object") ||
                     // Tuples already lift into ordinary array slots. Consider that
                     // same conversion when the array is an arm of a union too.
@@ -5456,9 +5528,30 @@ export class Lowerer {
                 if (sameFamily && this.widthLiftPlan(src, arm) !== null)
                     candidates.push({ tag: i, arm });
             });
-            if (candidates.length !== 1)
+            let selected = candidates;
+            if (selected.length > 1 && src.kind === "record") {
+                const source = this.shapes.get(src.shapeId);
+                // An inferred JS union may widen its tag while retaining variants
+                // with and without a value. Prefer the unique layout whose omitted
+                // fields are explicitly undefined, rather than filling an optional
+                // unknown slot and making both variants look equally compatible.
+                const absentOnly = selected.filter(({ arm }) => {
+                    if (!source || arm.kind !== "record")
+                        return false;
+                    const target = this.shapes.get(arm.shapeId);
+                    return target !== undefined && target.fields.every((field) => {
+                        if (source.fields.some((present) => present.name === field.name))
+                            return true;
+                        return isUnitType(field.type) || field.type.kind === "union" &&
+                            this.unions.get(field.type.unionId)?.arms.every(isUnitType) === true;
+                    });
+                });
+                if (absentOnly.length === 1)
+                    selected = absentOnly;
+            }
+            if (selected.length !== 1)
                 return null;
-            return { how: "liftWrap", tag: candidates[0].tag, arm: candidates[0].arm };
+            return { how: "liftWrap", tag: selected[0].tag, arm: selected[0].arm };
         }
         // A UNION source into a slot that is ONE of its arms (a width copy
         // whose target field narrowed — the option-table choices shape:
@@ -7100,6 +7193,10 @@ export class Lowerer {
         const to = this.unions.get(toId);
         if (!from || !to)
             return null;
+        const request = `${fromId}:${toId}:${trappable === undefined ? "" : [...trappable].sort((a, b) => a - b).join(".")}`;
+        const cached = this.copyRetagHelpers.get(request);
+        if (cached && cached.shapes === this.shapes.revision && cached.unions === this.unions.revision)
+            return cached.name;
         const plan = planUnionRetag(from, to, (id) => this.shapes.get(id), (src, dst) => this.widthLiftPlan(src, dst), trappable);
         if (plan === null)
             return null;
@@ -7111,11 +7208,17 @@ export class Lowerer {
             stranded.push(tag); });
         const key = `${fromId}:${toId}:${stranded.join(".")}`;
         const existing = this.retagHelpers.get(key);
-        if (existing)
-            return existing;
-        const name = `%union.retag.${this.retagHelpers.size}`;
-        this.retagHelpers.set(key, name);
-        this.liftedFns.push(buildUnionRetag(name, from, to, plan, loc, (lift, value, dst) => this.applyWidthLift(lift, value, dst, loc), (type) => this.fmt(type)));
+        const name = existing ?? `%union.retag.${this.retagHelpers.size}`;
+        if (!existing) {
+            this.retagHelpers.set(key, name);
+            this.liftedFns.push(buildUnionRetag(name, from, to, plan, loc, (lift, value, dst) => this.applyWidthLift(lift, value, dst, loc), (type) => this.fmt(type)));
+        }
+        // Width routes still revalidate on every request. Only a complete plan
+        // of exact payload copies and site-proven traps can bypass planning.
+        if (plan.every((arm) => arm.kind === "trap" || (arm.kind === "direct"
+            ? arm.route.lift.how === "copy" : arm.routes.every((route) => route.lift.how === "copy")))) {
+            this.copyRetagHelpers.set(request, { name, shapes: this.shapes.revision, unions: this.unions.revision });
+        }
         return name;
     }
     /** Interned `%union.narrow.<n>(u)` — the CHECKED single-arm extraction
@@ -7588,7 +7691,7 @@ export class Lowerer {
                 const property = this.checker.getPropertyOfType(this.typeOf(literal), def.discriminant.field);
                 if (property && !(property.flags & (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor))) {
                     const values = literalValues(this.checker.getTypeOfSymbol(property));
-                    const arm = values && literalUnionArm(def, values, (id) => this.shapes.get(id));
+                    const arm = values && this.literalUnionArm(def.id, values);
                     if (arm)
                         expr = this.coerceInto(node, expr, arm);
                 }
@@ -7611,7 +7714,9 @@ export class Lowerer {
                 }
             }
         }
-        let e = this.coerceToExpected(expr, expected);
+        let e = this.dynamic && expr.type.kind === "dyn" && expected.kind === "array" && expected.elem.kind === "jsval"
+            ? { kind: "jsExit", value: this.jsvalIn(expr, node), type: expected, loc: expr.loc }
+            : this.coerceToExpected(expr, expected);
         // Existing JavaScript arrays retain mutations and identity across checked
         // slots. Fresh literals have no prior identity and use checked storage
         // directly, so later writes can change their inferred element type.
@@ -7857,7 +7962,7 @@ export class Lowerer {
                 const property = this.checker.getPropertyOfType(this.typeOf(node), def.discriminant.field);
                 if (property && !(property.flags & (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor))) {
                     const values = literalValues(this.checker.getTypeOfSymbol(property));
-                    const arm = values && literalUnionArm(def, values, (id) => this.shapes.get(id));
+                    const arm = values && this.literalUnionArm(def.id, values);
                     if (arm)
                         return this.coerceInto(node, this.lowerObjectLiteral(node, arm), expected);
                 }
@@ -7865,7 +7970,7 @@ export class Lowerer {
         }
         // An OBJECT LITERAL against a checked-dynamic slot in a JS file (the
         // getSupportInfo options argument — a dyn-ABI param), or against the
-        // standard RequestInit/ErrorOptions types in TypeScript: the value's world IS the
+        // standard native option-bag types in TypeScript: the value's world IS the
         // checked-dynamic tree — build the dyn literal directly.
         if (expected?.kind === "dyn") {
             let x = node;
@@ -7885,7 +7990,8 @@ export class Lowerer {
                 return sym?.name === name && this.isStdlibSymbol(sym);
             });
             if (ts.isObjectLiteralExpression(x)) {
-                if (isJsSourceFile(x.getSourceFile()) || builtinOption("RequestInit") || builtinOption("ErrorOptions")) {
+                if (isJsSourceFile(x.getSourceFile()) || builtinOption("RequestInit") || builtinOption("ErrorOptions") || builtinOption("SpawnOptions") ||
+                    !this.mapTypeOf(this.typeOf(x))) {
                     return lowerDynObjectLiteral(this, x);
                 }
             }
@@ -8096,14 +8202,17 @@ export class Lowerer {
     stripUndefinedArm(t) {
         if (t.kind !== "union")
             return t;
+        const cached = this.strippedUndefinedArms.get(t.unionId);
+        if (cached && cached.unions === this.unions.revision)
+            return cached.type;
         const def = this.unions.get(t.unionId);
-        if (!def || !def.arms.some((a) => a.kind === "undefinedT"))
+        if (!def || this.armTag(t.unionId, UNDEFINED_T) < 0)
             return t;
         const rest = def.arms.filter((a) => a.kind !== "undefinedT");
-        if (rest.length === 1)
-            return rest[0];
         // Removing an arm keeps canonical (typeKey-sorted) order.
-        return { kind: "union", unionId: this.unions.transform(def, rest) };
+        const type = rest.length === 1 ? rest[0] : { kind: "union", unionId: this.unions.transform(def, rest) };
+        this.strippedUndefinedArms.set(t.unionId, { type, unions: this.unions.revision });
+        return type;
     }
     /** The interned `T | undefined` union over a non-union arm type — the ABI
      * type of a defaulted parameter, and the result type of lookups that may
@@ -8164,13 +8273,14 @@ export class Lowerer {
      * symbol reports eagerly (nothing could ever reference it). */
     collectDeferring(symbolOf, collect) {
         const sink = [];
+        const previousSink = this.diagSink;
         this.diagSink = sink;
         try {
             collect();
             return null;
         }
         catch (e) {
-            this.diagSink = null;
+            this.diagSink = previousSink;
             const symbol = (() => {
                 // symbolOf queries the checker too — a second panic must not
                 // escape the fence that is handling the first.
@@ -8203,7 +8313,7 @@ export class Lowerer {
             return symbol;
         }
         finally {
-            this.diagSink = null;
+            this.diagSink = previousSink;
         }
     }
     /** Pushes a symbol's deferred collection diagnostics: lowering resolved
@@ -8384,6 +8494,8 @@ export class Lowerer {
      * BEFORE that statement (JS's order for the supported whole-initializer
      * positions). */
     pendingClassExprInits = [];
+    computedClassBases = new Map();
+    computedCallableBases = new Map();
     /** Discovery hook: registers a just-collected expression class's member
      * bodies as worklist units (the units map is otherwise built before
      * lowering starts). Null in the emit pass. */
@@ -8472,11 +8584,7 @@ export class Lowerer {
             // Computed method names resolve exactly like collection did
             // (classMemberNameOf — folded keys and the sym:iterator slot);
             // unresolvable ones never collected, so they skip here too.
-            const baseName = ts.isMethodDeclaration(fnLike)
-                ? classMemberNameOf(this, fnLike.name)
-                : ts.isIdentifier(fnLike.name) || ts.isPrivateIdentifier(fnLike.name)
-                    ? fnLike.name.text
-                    : null;
+            const baseName = classMemberNameOf(this, fnLike.name);
             if (baseName === null)
                 continue;
             const mName = ts.isMethodDeclaration(fnLike) ? baseName : `${ts.isGetAccessor(fnLike) ? "get" : "set"}:${baseName}`;
@@ -8847,9 +8955,7 @@ export class Lowerer {
         });
         if (resolved.error !== null) {
             const location = blame ?? (symbol === undefined ? undefined : this.checker.declarationsOf(symbol)[0]) ?? this.entry;
-            const message = resolved.error === "caught"
-                ? "closures capturing catch bindings (narrow into a typed local first)"
-                : `the binding '${resolved.origin.name}' captured through a plain nested function (the declaration has no static storage a capture can thread — bind the value through a typed const, or read it in the declaring scope)`;
+            const message = `the binding '${resolved.origin.name}' captured through a plain nested function (the declaration has no static storage a capture can thread — bind the value through a typed const, or read it in the declaring scope)`;
             this.unsupported("SC1090", location, message);
         }
         if (resolved.local !== null)
@@ -9238,7 +9344,16 @@ export class Lowerer {
         return isStdlibMember(this, access);
     }
     isStdlibSymbol(symbol) {
-        return isStdlibSymbol(this, symbol);
+        if (!symbol)
+            return false;
+        const cached = this.stdlibSymbols.get(symbol);
+        if (cached !== undefined)
+            return cached;
+        // A compilation's checker declarations and library provenance are fixed.
+        // Global alias and narrowing state remain outside this symbol-only cache.
+        const result = isStdlibSymbol(this, symbol);
+        this.stdlibSymbols.set(symbol, result);
+        return result;
     }
     isStdlibGlobal(expr, name) {
         return isStdlibGlobal(this, expr, name);
@@ -9580,7 +9695,7 @@ export class Lowerer {
             const arg = this.lowerExpr(expr.arguments[0]);
             return { kind: "jsOp", op: "construct", args: [ctor, arg], type: JSVAL, loc };
         }
-        const builtin = lowerAbortControllerNew(this, expr) ?? lowerResponseNew(this, expr) ?? lowerStaticReadableStreamNew(this, expr);
+        const builtin = lowerAbortControllerNew(this, expr) ?? lowerFetchWebNew(this, expr) ?? lowerResponseNew(this, expr) ?? lowerStaticReadableStreamNew(this, expr);
         return builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr));
     }
     lowerFieldRead(expr) {
@@ -9862,10 +9977,10 @@ export class Lowerer {
         if (!expr.questionDotToken && ts.isPropertyAccessExpression(expr.expression)) {
             const inner = this.builtinMemberOf(expr.expression);
             if (inner && inner.module === "fs" && inner.member === "constants") {
-                const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4 };
+                const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4, COPYFILE_EXCL: 1, COPYFILE_FICLONE: 2, COPYFILE_FICLONE_FORCE: 4 };
                 const value = own(MODES, expr.name.text);
                 if (value === undefined) {
-                    this.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
+                    this.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
                 }
                 return { kind: "numLit", value, type: F64, loc };
             }
@@ -9873,6 +9988,10 @@ export class Lowerer {
         const bi = this.builtinMemberOf(expr);
         if (!bi)
             return null;
+        if ((bi.module === "path" || bi.module === "path/posix" || bi.module === "path/win32") &&
+            (bi.member === "posix" || bi.member === "win32")) {
+            return pathModuleValue(this, `path/${bi.member}`, loc);
+        }
         // events.defaultMaxListeners READS the process-wide default (its
         // write twin routes through emitter.setDefaultMaxChk).
         if (bi.module === "events" && bi.member === "defaultMaxListeners") {
@@ -9908,7 +10027,7 @@ export class Lowerer {
         }
         if (bi.member === "constants" && bi.module === "fs") {
             // A bare `fs.constants` read (not one of the baked bits above).
-            this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
+            this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
         }
         if (builtinModuleFnOf(this, bi.module, bi.member)) {
             this.unsupported("SC1090", expr, `library functions as values (call '${expr.getText()}' directly)`);
@@ -9921,6 +10040,9 @@ export class Lowerer {
      * deliberately narrower than table membership because many table rows
      * are only dispatch sentinels for call-site-specific lowering. */
     lowerBuiltinCallableValue(bi, loc) {
+        if (bi.module === "fs" && builtinModuleFnOf(this, bi.module, bi.member)?.fn === "fs.callbackCall") {
+            return { kind: "libCall", fn: "fs.callbackValue", args: [{ kind: "strLit", value: bi.member, type: STRING, loc }], type: DYN, loc };
+        }
         const fn = builtinModuleFnOf(this, bi.module, bi.member);
         return fn ? this.lowerNativeCallableValue(fn, `${bi.module}.${bi.member}`, loc) : null;
     }