@scriptc/compiler 0.0.3 → 0.0.5

package/dist/frontend/lowering/lowerer.js

@@ -17,10 +17,10 @@ import * as ts from "../ts7/adapter.js";
 import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, noLoweringDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, F64, isJsonSafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/nodes.js";
 import { provenanceActive } from "../provenance-registry.js";
-import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, overridesDtsPath, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
+import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.js";
 import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
-import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
+import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, findGenericMethodOn, findGenericStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorMessageArg, lowerNew, accessorCall } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mixins.js";
 import { bindingNeverReassigned, bodyReadsArguments, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction } from "./lower-calls.js";
@@ -148,7 +148,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const dynamic = options.dynamic ?? false;
     const targetPlatform = options.targetPlatform ?? process.platform;
     const startupCrash = options.startupCrash ?? null;
-    const reachable = new Lowerer(program, entry, moduleOrder, dynamic, { targetPlatform }).discover();
+    const reachable = new Lowerer(program, entry, moduleOrder, dynamic, { targetPlatform }).discover(options.libRoots);
     const emit = new Lowerer(program, entry, moduleOrder, dynamic, { reachable, targetPlatform, startupCrash });
     const result = emit.run();
     if (options.coverage !== true)
@@ -568,6 +568,12 @@ export class Lowerer {
     /** Synthetic URLSearchParams.forEach loop functions, interned per
      * callback arity/return — Map's pattern over the sp index walk. */
     spHofHelpers = new Map();
+    /** The primitive-constructor VALUES (`String`/`Number`/`Boolean` as
+     * bare identifiers — CLI option tables store and compare them): one
+     * synthesized coercion function per constructor per program, interned
+     * here by name so every reference is the SAME zero-capture closure and
+     * `opt.type === String` is JS identity (see primitiveCtorClosure). */
+    primitiveCtorFns = new Map();
     /** Optional-chain lowering state. While a chain body lowers, the guarded
      * receiver NODE reads as a chainRecv (typed by the narrowed arm) instead
      * of re-lowering, its checker type reads non-nullish (typeOf), and the
@@ -918,6 +924,16 @@ export class Lowerer {
                 this.flushDeferred(symbol);
                 return symbol;
             }
+            // DEFAULT-SNAPSHOT storage lives on the EXPORTER'S default alias
+            // symbol (`export default someLet` — collectGlobals registers the
+            // Node-semantics snapshot there). getAliasedSymbol would resolve
+            // PAST it to the live let; walk the default-import hops and stop at
+            // the first default symbol carrying storage instead.
+            const snap = this.defaultSnapshotSymbolOf(symbol);
+            if (snap) {
+                this.flushDeferred(snap);
+                return snap;
+            }
             symbol = this.checker.getAliasedSymbol(symbol);
         }
         // CommonJS export plumbing: a binding that resolved to a PROPERTY of a
@@ -933,6 +949,51 @@ export class Lowerer {
         this.flushDeferred(symbol);
         return symbol;
     }
+    /** The default-snapshot storage symbol a DEFAULT-import alias chain
+     * lands on, or null. A mutable entity-name default (`export default
+     * someLet`) registers its Node-semantics snapshot global under the
+     * exporter's default ALIAS symbol; the checker's getAliasedSymbol
+     * resolves through that symbol to the live let, so this walk follows
+     * the default hops syntactically — default import clauses, `{ default
+     * as x }` specifiers, `export { default } from` re-exports — and stops
+     * at the first default symbol carrying registered storage. Local
+     * `export { x as default }` specifiers (no module specifier) are LIVE
+     * bindings in Node and fall through to ordinary alias resolution. */
+    defaultSnapshotSymbolOf(alias) {
+        let sym = alias;
+        for (let hop = 0; sym !== undefined && hop < 32; hop++) {
+            if (hop > 0 && sym.flags & ts.SymbolFlags.Alias && this.globalsBySymbol.has(sym))
+                return sym;
+            const d = this.checker
+                .declarationsOf(sym)
+                .find((x) => ts.isImportClause(x) || ts.isImportSpecifier(x) || ts.isExportSpecifier(x));
+            let spec;
+            let name;
+            if (d && ts.isImportClause(d) && ts.isImportDeclaration(d.parent)) {
+                spec = d.parent.moduleSpecifier;
+                name = "default";
+            }
+            else if (d && ts.isImportSpecifier(d)) {
+                const idecl = d.parent.parent.parent;
+                if (ts.isImportDeclaration(idecl))
+                    spec = idecl.moduleSpecifier;
+                name = (d.propertyName ?? d.name).text;
+            }
+            else if (d && ts.isExportSpecifier(d)) {
+                const edecl = d.parent.parent;
+                if (ts.isExportDeclaration(edecl))
+                    spec = edecl.moduleSpecifier;
+                name = (d.propertyName ?? d.name).text;
+            }
+            if (d === undefined || spec === undefined || !ts.isStringLiteral(spec) || name !== "default")
+                return null;
+            const dep = resolveImport(this.program, d.getSourceFile(), spec.text);
+            if (!dep)
+                return null;
+            sym = defaultExportSymbolOf(this, dep) ?? undefined;
+        }
+        return null;
+    }
     /** A module's CJS export-table member symbol by NAME (the checker's
      * module-symbol exports map — present in tsgo even where no expando
      * property symbol exists at the attachment/use sites). */
@@ -1018,9 +1079,13 @@ export class Lowerer {
             return null;
         }
         const spec = importDecl.moduleSpecifier.text;
-        if (!isRelativeSpecifier(spec))
-            return null;
-        const dep = resolveImport(this.program, importDecl.getSourceFile(), spec);
+        // Bare specifiers resolve only for opted-in --npm-static packages —
+        // their CJS entries take the same default-binding interop as a
+        // relative require; every other bare import answers null and keeps
+        // its own machinery.
+        const dep = isRelativeSpecifier(spec)
+            ? resolveImport(this.program, importDecl.getSourceFile(), spec)
+            : npmStaticDepSf7(this.program, importDecl.getSourceFile(), spec);
         if (!dep || !isJsSourceFile(dep) || isNodeEsmFile(dep))
             return null;
         return dep;
@@ -1376,6 +1441,20 @@ export class Lowerer {
         // the emitted program references, flushing deferred class diagnostics
         // that a reached type makes relevant.
         const artifacts = this.moduleArtifacts(functions);
+        // Types still naming a class that never REGISTERED after retention's
+        // flush (JS graphs whose class fences deferred to runtime — the
+        // sentence-walker's path params, printer tables whose func-typed
+        // fields spell the fenced class): the emitter would name a struct
+        // that does not exist — the compile-C escape family. No instance of
+        // such a class can ever exist (every construction site fenced), so
+        // the slots are inert by construction: rewrite each to the f64 dummy
+        // placeholder (boxNewC's uncollected-class stance, applied to unboxed
+        // slots), uniformly across params/locals/globals/fields/body types so
+        // every producer and consumer agrees. Programs with no unregistered
+        // reference are untouched — byte-stability holds.
+        if (this.diags.length === 0) {
+            this.sanitizeUnregisteredClassTypes([functions, this.globalsList, artifacts.classes, artifacts.records, artifacts.unions]);
+        }
         const module = this.diags.length > 0
             ? null
             : {
@@ -1400,6 +1479,45 @@ export class Lowerer {
             ...(this.npmLazyTraps ? { npmLazyTraps: this.npmLazyTraps } : {}),
         };
     }
+    /** The unregistered-class type sweep (run()'s last step before the
+     * module assembles): every `{kind:"object"}` TYPE naming a class with
+     * no registered ClassInfo is rewritten IN PLACE to the f64 dummy.
+     * classval types are exempt (they emit the class-independent
+     * `ScrClassObj *` — inert-but-valid storage, the validator's own
+     * stance), and only type objects rewrite — node-level classNames
+     * (`new`, upcasts) cannot reach here (their lowerings fence without a
+     * registered class), so the validator still backstops those. */
+    sanitizeUnregisteredClassTypes(roots) {
+        const isUnregisteredObjectType = (v) => typeof v === "object" && v !== null &&
+            v.kind === "object" &&
+            typeof v.className === "string" &&
+            !this.classes.has(v.className);
+        const sweep = (node) => {
+            if (node === null || typeof node !== "object")
+                return;
+            if (Array.isArray(node)) {
+                node.forEach((item, i) => {
+                    if (isUnregisteredObjectType(item))
+                        node[i] = F64;
+                    else
+                        sweep(item);
+                });
+                return;
+            }
+            const rec = node;
+            for (const key of Object.keys(rec)) {
+                if (key === "loc")
+                    continue;
+                const v = rec[key];
+                if (isUnregisteredObjectType(v))
+                    rec[key] = F64;
+                else
+                    sweep(v);
+            }
+        };
+        for (const root of roots)
+            sweep(root);
+    }
     /** True when `t` (recursively) names a class instance type with no
      * registered ClassInfo — the shape of a JS class whose collection fenced.
      * Used by run()'s global pruning; shapes/unions recurse with a seen-set
@@ -1461,7 +1579,7 @@ export class Lowerer {
      * demand-driven) and lifted lambdas lower inline with their enclosing
      * body; both fire edges through the same hooks and are not units
      * themselves. */
-    discover() {
+    discover(extraRoots) {
         const parts = this.splitFiles();
         this.collectProgram(parts);
         // Decorated classes analyze post-collection here too: the %init seeds
@@ -1569,6 +1687,12 @@ export class Lowerer {
             this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf));
             drainInstances();
         });
+        // LIBRARY mode's extra reachability roots (LowerOptions.libRoots): the
+        // profile-mapped exports are called from outside the graph, so they
+        // seed the worklist beside the init bodies. Unknown names are inert
+        // (the export-map resolution reports them as SC4002 later).
+        for (const root of extraRoots ?? [])
+            this.onEdge?.(root);
         while (queue.length > 0) {
             // A body-level poison outside the per-statement catches (a fenced
             // constructor/method parameter default lowered by declareParams):
@@ -2459,9 +2583,15 @@ export class Lowerer {
         }
         if (expected.kind === "array" && expr.type.kind === "array" && expected.elem.kind !== "jsval") {
             const helper = this.arrayWidthHelper(expr.type, expected, expr.loc);
-            if (!helper)
+            if (helper)
+                return { kind: "call", callee: helper, args: [expr], type: expected, loc: expr.loc };
+            // The EMPTY-array lift (widthLiftPlan's emptyArr rule), top-level:
+            // `cmd.aliases` typed `(null | undefined)[]` (an `aliases: []`
+            // table) flowing into a `string[]` slot.
+            const lift = this.widthLiftPlan(expr.type, expected);
+            if (lift?.how !== "emptyArr")
                 return null;
-            return { kind: "call", callee: helper, args: [expr], type: expected, loc: expr.loc };
+            return this.applyWidthLift(lift, expr, expected, expr.loc);
         }
         // A TUPLE flowing into an array slot (`const NAMES = [...] as const`
         // assigned to a `readonly T[]` — the const-table pattern): TS erases
@@ -2547,10 +2677,39 @@ export class Lowerer {
             return this.recordToClassPlan(src.shapeId, dst.className) !== null ? { how: "clsWidth" } : null;
         }
         if (dst.kind === "array" && src.kind === "array") {
-            return this.widthLiftPlan(src.elem, dst.elem) !== null ? { how: "arr" } : null;
+            if (this.widthLiftPlan(src.elem, dst.elem) !== null)
+                return { how: "arr" };
+            // The EMPTY-array lift: a unit-only element type (`readonly []`
+            // mapped as the unit-element array, `(null | undefined)[]`) has no
+            // per-element conversion into a data element — but the only value
+            // such a slot honestly holds in the width family is EMPTY, so the
+            // lift is a fresh empty array of the target type, guarded by a
+            // runtime non-empty trap (the checked-extraction stance).
+            if (this.unitOnlyElem(src.elem) && dst.elem.kind !== "jsval" && !this.unitOnlyElem(dst.elem)) {
+                return { how: "emptyArr" };
+            }
+            return null;
+        }
+        // A TUPLE flowing into an array FIELD/ELEMENT (`aliases: ["ls"]` into
+        // an `aliases: string[]` slot): per-position lifts, the top-level
+        // tuple-into-array coercion applied recursively.
+        if (dst.kind === "array" && src.kind === "record" && dst.elem.kind !== "jsval") {
+            const from = this.shapes.get(src.shapeId);
+            if (from?.tuple && from.fields.every((f) => this.widthLiftPlan(f.type, dst.elem) !== null)) {
+                return { how: "tupleArr" };
+            }
+            return null;
         }
         return null;
     }
+    /** True for the unit-only element types (`(null | undefined)[]`, the
+     * `readonly []` mapping): a union whose every arm is a unit. */
+    unitOnlyElem(t) {
+        if (t.kind !== "union")
+            return false;
+        const def = this.unions.get(t.unionId);
+        return def !== undefined && def.arms.every((a) => isUnitType(a));
+    }
     /** The build side of widthLiftPlan: the IrExpr converting `value` into
      * `dst` under a plan the caller validated. Interns whatever helpers the
      * lift needs (planned first, so the interns cannot fail — a failure here
@@ -2597,6 +2756,20 @@ export class Lowerer {
                     throw new Error("lowerer bug: planned arr lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
+            case "tupleArr": {
+                if (dst.kind !== "array" || value.type.kind !== "record")
+                    throw new Error("lowerer bug: tupleArr lift shape");
+                const helper = this.tupleArrayWidthHelper(value.type.shapeId, dst, loc);
+                if (!helper)
+                    throw new Error("lowerer bug: planned tupleArr lift failed to intern");
+                return { kind: "call", callee: helper, args: [value], type: dst, loc };
+            }
+            case "emptyArr": {
+                if (dst.kind !== "array" || value.type.kind !== "array")
+                    throw new Error("lowerer bug: emptyArr lift shape");
+                const helper = this.emptyArrayLiftHelper(value.type, dst, loc);
+                return { kind: "call", callee: helper, args: [value], type: dst, loc };
+            }
             case "objWidth": {
                 if (dst.kind !== "record" || value.type.kind !== "object")
                     throw new Error("lowerer bug: objWidth lift shape");
@@ -2660,10 +2833,19 @@ export class Lowerer {
                 if (!ff) {
                     // A target field MISSING on the source: legal exactly when it is
                     // optional-flavored (an undefined-armed union) — the unset field
-                    // IS the undefined arm, the same rule literal completion applies.
-                    // Never for tuples: a completed position would change .length
-                    // and JSON where Node keeps the source arity.
-                    if (from.tuple || tf.type.kind !== "union")
+                    // IS the undefined arm, the same rule literal completion applies
+                    // — or 'unknown' (a dyn slot holds the DOM undefined, exactly
+                    // the absent-property read: the options-record call shape
+                    // against `{ plugins: unknown, ... }`). Never for tuples: a
+                    // completed position would change .length and JSON where Node
+                    // keeps the source arity.
+                    if (from.tuple)
+                        return null;
+                    if (tf.type.kind === "dyn") {
+                        plan.set(tf.name, { absentDyn: true });
+                        continue;
+                    }
+                    if (tf.type.kind !== "union")
                         return null;
                     const def = this.unions.get(tf.type.unionId);
                     const utag = def ? def.arms.findIndex((a) => a.kind === "undefinedT") : -1;
@@ -2717,6 +2899,11 @@ export class Lowerer {
                         kind: "recordLit",
                         fields: to.fields.map((f) => {
                             const lift = plan.get(f.name);
+                            if ("absentDyn" in lift) {
+                                // The unset 'unknown' field: the DOM undefined — exactly
+                                // the absent-property read's answer.
+                                return { name: f.name, value: dynUndefinedExpr(loc) };
+                            }
                             if ("absent" in lift) {
                                 if (f.type.kind !== "union")
                                     throw new Error("lowerer bug: absent lift against a non-union field");
@@ -2796,6 +2983,57 @@ export class Lowerer {
         });
         return name;
     }
+    /** Interned `%arr.empty.<n>(a)` — the EMPTY-array lift's build side: a
+     * unit-only-element array reshapes into any data-element array by
+     * answering a FRESH empty array, after a runtime non-empty trap (a
+     * genuinely inhabited `(null | undefined)[]` cannot reshape — the
+     * catchable-TypeError stance every checked extraction takes). */
+    emptyArrayLiftHelper(fromT, toT, loc) {
+        const key = `emptyarr:${typeKey(fromT.elem)}:${typeKey(toT.elem)}`;
+        const existing = this.widthHelpers.get(key);
+        if (existing)
+            return existing;
+        const name = `%arr.empty.${this.widthHelpers.size}`;
+        this.widthHelpers.set(key, name);
+        const a = { kind: "varRef", localId: "a.0", type: fromT, loc };
+        this.liftedFns.push({
+            name,
+            params: [{ localId: "a.0", name: "a", type: fromT }],
+            returnType: toT,
+            locals: [{ id: "a.0", name: "a", type: fromT, mutable: true }],
+            body: [
+                {
+                    kind: "if",
+                    cond: {
+                        kind: "bin",
+                        op: "!==",
+                        left: { kind: "arrIntrinsic", method: "length", receiver: a, args: [], type: F64, loc },
+                        right: { kind: "numLit", value: 0, type: F64, loc },
+                        type: BOOL,
+                        loc,
+                    },
+                    then: [
+                        {
+                            kind: "throw",
+                            value: {
+                                kind: "libCall",
+                                fn: "error.new",
+                                args: [{ kind: "strLit", value: `expected ${this.fmt(toT)} (a non-empty ${this.fmt(fromT)} has no elements the target can hold)`, type: STRING, loc }],
+                                type: { kind: "object", className: "%TypeError" },
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                    else_: [],
+                    loc,
+                },
+                { kind: "return", value: { kind: "arrayLit", elems: [], type: toT, loc }, loc },
+            ],
+            loc,
+        });
+        return name;
+    }
     arrayWidthHelper(fromT, toT, loc) {
         const fromElem = fromT.elem;
         const toElem = toT.elem;
@@ -3932,6 +4170,59 @@ export class Lowerer {
         });
         return name;
     }
+    /** The DEFERRED-INIT field read (`stream!: T` assigned past the
+     * constructor's top level — the slot is `T | undefined`): interned
+     * `%deferred.read.<n>(u)` extracting the declared type. SCALAR arms
+     * whose JS-undefined behavior a unit default reproduces read that
+     * default — bool false (conditions are exact: undefined and false are
+     * both falsy; only printing/strict-equality could tell) and f64 NaN
+     * (arithmetic and conditions exact) — while string and REF arms keep
+     * the checked-extraction TRAP: JS itself TypeErrors the first member
+     * use of such an undefined, so the catchable TypeError at the read is
+     * the same failure, named earlier (SEMANTICS.md). */
+    deferredReadHelper(fromId, target, loc) {
+        if (target.kind !== "bool" && target.kind !== "f64") {
+            return this.narrowedArmHelper(fromId, target, loc);
+        }
+        const from = this.unions.get(fromId);
+        const tag = this.armTag(fromId, target);
+        const utag = from ? from.arms.findIndex((a) => a.kind === "undefinedT") : -1;
+        if (!from || tag < 0 || utag < 0)
+            return null;
+        const key = `deferred:${fromId}:${tag}`;
+        const existing = this.narrowHelpers.get(key);
+        if (existing)
+            return existing;
+        const name = `%deferred.read.${this.narrowHelpers.size}`;
+        this.narrowHelpers.set(key, name);
+        const fromT = { kind: "union", unionId: fromId };
+        const u = { kind: "varRef", localId: "u.0", type: fromT, loc };
+        const dflt = target.kind === "bool"
+            ? { kind: "boolLit", value: false, type: BOOL, loc }
+            : { kind: "numLit", value: NaN, type: F64, loc };
+        this.liftedFns.push({
+            name,
+            params: [{ localId: "u.0", name: "u", type: fromT }],
+            returnType: target,
+            locals: [{ id: "u.0", name: "u", type: fromT, mutable: true }],
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "unionIsTag", unionId: fromId, tag: utag, negated: false, value: u, type: BOOL, loc },
+                    then: [{ kind: "return", value: dflt, loc }],
+                    else_: null,
+                    loc,
+                },
+                {
+                    kind: "return",
+                    value: { kind: "unionNarrow", unionId: fromId, tag, value: u, type: target, loc },
+                    loc,
+                },
+            ],
+            loc,
+        });
+        return name;
+    }
     /** True when a static value can become ONE island value: jsval itself,
      * anything boundary-safe (the deep JSON marshal), a record whose fields
      * all can (built as an island OBJECT literal, field by field), or an
@@ -4851,7 +5142,7 @@ export class Lowerer {
             // unresolvable ones never collected, so they skip here too.
             const baseName = ts.isMethodDeclaration(fnLike)
                 ? classMemberNameOf(this, fnLike.name)
-                : ts.isIdentifier(fnLike.name)
+                : ts.isIdentifier(fnLike.name) || ts.isPrivateIdentifier(fnLike.name)
                     ? fnLike.name.text
                     : null;
             if (baseName === null)
@@ -5192,6 +5483,27 @@ export class Lowerer {
     resolveThis() {
         return this.resolveKey(THIS_BINDING);
     }
+    /** READ-ONLY twin of resolveLocal for PROBES (isIslandExpr): answers
+     * the nearest binding entry without boxing, threading, or predeclaring.
+     * resolveKey mutates capture state as a side effect, and a speculative
+     * island-ness query through a context that takes no captures (a plain
+     * declared function between the origin and the reference) was an ICE —
+     * the REAL lowering path still resolves (and diagnoses) the reference
+     * itself. */
+    peekLocal(ident) {
+        let symbol = this.checker.getSymbolAtLocation(ident);
+        if (ident.parent && ts.isShorthandPropertyAssignment(ident.parent) && ident.parent.name === ident) {
+            symbol = this.checker.getShorthandAssignmentValueSymbol(ident.parent) ?? symbol;
+        }
+        if (!symbol)
+            return null;
+        for (let depth = this.fnStack.length - 1; depth >= 0; depth--) {
+            const hit = this.bindingIn(this.fnStack[depth], symbol);
+            if (hit)
+                return hit;
+        }
+        return null;
+    }
     resolveKey(symbol, blame) {
         const direct = this.bindingIn(this.ctx, symbol);
         if (direct)
@@ -5225,6 +5537,17 @@ export class Lowerer {
                 const ctx = this.fnStack[j];
                 let entry = ctx.captureBySymbol.get(symbol);
                 if (!entry) {
+                    // A context that takes NO captures (a plain declared function —
+                    // monomorphized/implicit instances lower this way) cannot carry
+                    // the binding through: the shape is a module binding whose only
+                    // storage is the init function's LOCAL (a typed-but-unmappable
+                    // const — the file-scope `new Map()` ledger idiom) read from
+                    // inside a nested instance. Fence it — in JS the statement
+                    // defers to its runtime trap like every collection failure;
+                    // asserting here was an ICE on ordinary npm-static JS.
+                    if (ctx.captures === null) {
+                        this.unsupported("SC1090", blame ?? this.checker.declarationsOf(symbol)[0] ?? this.entry, `the binding '${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 count = ctx.localCounters.get(origin.name) ?? 0;
                     ctx.localCounters.set(origin.name, count + 1);
                     entry = {
@@ -5239,9 +5562,6 @@ export class Lowerer {
                     };
                     ctx.locals.push(entry);
                     ctx.captureBySymbol.set(symbol, entry);
-                    if (ctx.captures === null) {
-                        throw new Error("lowerer bug: capture threading through a non-lifted function");
-                    }
                     ctx.captures.push({ localId: entry.id, name: entry.name, type: entry.type });
                     ctx.captureSources.push(parentEntry.id);
                 }
@@ -5947,7 +6267,7 @@ export class Lowerer {
         if (module !== null)
             return { module, member: access.name.text };
         // The RE-EXPORT FACADE's namespace spelling: `import * as assert from
-        // "./facade.js"` over `export { ok } from "node:assert"` (prettier's
+        // "./facade.js"` over `export { ok } from "node:assert"` (the formatter idiom's
         // universal/assert). The member's symbol is the facade's
         // ExportSpecifier, and builtinImportOf's alias chase answers the
         // builtin's own module/member — the same tables as a direct import;