@scriptc/compiler 0.0.2 → 0.0.4

package/dist/frontend/lowering/lowerer.d.ts

@@ -33,6 +33,10 @@ export type WidthLift = {
     how: "width";
 } | {
     how: "arr";
+} | {
+    how: "tupleArr";
+} | {
+    how: "emptyArr";
 } | {
     how: "objWidth";
 } | {
@@ -436,6 +440,12 @@ export declare class Lowerer {
     /** Synthetic URLSearchParams.forEach loop functions, interned per
      * callback arity/return — Map's pattern over the sp index walk. */
     readonly spHofHelpers: Map<string, string>;
+    /** 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). */
+    readonly primitiveCtorFns: Map<string, string>;
     /** 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
@@ -672,6 +682,17 @@ export declare class Lowerer {
      * point for deferred collection diagnostics: resolving a reference to a
      * broken declaration reports what collection deferred. */
     resolveValueSymbol(ident: ts.Identifier): ts.Symbol | null;
+    /** 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. */
+    private defaultSnapshotSymbolOf;
     /** 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). */
@@ -734,6 +755,15 @@ export declare class Lowerer {
     collectNpmImports(parts: FileParts[]): void;
     collectJsonImports(parts: FileParts[]): void;
     run(): LowerResult;
+    /** 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: unknown[]): void;
     /** 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
@@ -904,6 +934,9 @@ export declare class Lowerer {
      *               copy loop, arrayWidthHelper)
      * Null when the pair isn't in the relation — callers keep their fences. */
     widthLiftPlan(src: IrType, dst: IrType): WidthLift | null;
+    /** True for the unit-only element types (`(null | undefined)[]`, the
+     * `readonly []` mapping): a union whose every arm is a unit. */
+    unitOnlyElem(t: IrType): boolean;
     /** 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
@@ -932,6 +965,8 @@ export declare class Lowerer {
     } | {
         absent: true;
         utag: number;
+    } | {
+        absentDyn: true;
     }> | null;
     recordWidthHelper(fromId: string, toId: string, loc: SrcLoc): string | null;
     /** Interned `%arr.width.<n>(a)` — the per-element copy loop over
@@ -947,6 +982,16 @@ export declare class Lowerer {
     tupleArrayWidthHelper(fromId: string, toT: IrType & {
         kind: "array";
     }, loc: SrcLoc): string | null;
+    /** 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: IrType & {
+        kind: "array";
+    }, toT: IrType & {
+        kind: "array";
+    }, loc: SrcLoc): string;
     arrayWidthHelper(fromT: IrType & {
         kind: "array";
     }, toT: IrType & {
@@ -1145,6 +1190,17 @@ export declare class Lowerer {
      * impossible value flow on). Null when the target isn't a non-unit arm
      * of the union — those uses keep their erasure/fences. */
     narrowedArmHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
+    /** 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: string, target: IrType, loc: SrcLoc): string | null;
     /** 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
@@ -1625,7 +1681,7 @@ export declare class Lowerer {
     rejectComptimeCaptures(cb: ts.ArrowFunction | ts.FunctionExpression): void;
     comptimeValueToIr(value: unknown, expected: IrType, path: string, blame: ts.Node): IrExpr;
     isConsoleLog(call: ts.CallExpression): boolean;
-    consoleCallMember(call: ts.CallExpression): "log" | "error" | "warn" | null;
+    consoleCallMember(call: ts.CallExpression): "log" | "info" | "debug" | "error" | "warn" | null;
     builtinImportOf(ident: ts.Identifier): {
         module: string;
         member: string;

package/dist/frontend/lowering/lowerer.js

@@ -20,7 +20,7 @@ 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 { 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";
@@ -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). */
@@ -1376,6 +1437,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 +1475,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
@@ -2459,9 +2573,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 +2667,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 +2746,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 +2823,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 +2889,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 +2973,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 +4160,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 +5132,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)
@@ -5947,7 +6228,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;