@scriptc/compiler 0.0.3 → 0.0.5

package/dist/frontend/lowering/lower-classes.d.ts

@@ -14,17 +14,30 @@ export interface ClassInfo {
     fieldOrder: {
         name: string;
         type: IrType;
-        initializer: ts.Expression | undefined;
+        initializer: ts.Expression | undefined; /** Redeclared INHERITED field: the initializer assigns the base slot at this position; no new slot (def.fields excludes it). */
+        redeclared?: true;
     }[];
     /** OWN declared methods only — inherited lookups walk the base chain
      * (findMethodOn). An `abstract` entry is a signature with no body (and
      * no module function): it declares the vtable slot; concrete subclasses
-     * fill it (tsc guarantees every instantiable class implements). */
+     * fill it (tsc guarantees every instantiable class implements).
+     * #PRIVATE members key by their spelled name ('#m', "get:#x") — no
+     * public identifier can collide, subclass redeclarations of an
+     * inherited private name are fenced at collection, and tsc confines
+     * every access site to the declaring class's body, so the base-chain
+     * walk IS lexical resolution and privates never join vtables (JS's
+     * no-dynamic-dispatch semantics by construction). A `gen` entry is a
+     * #private GENERATOR method: the body is a generator IrFunction and
+     * calls enter through its gen-spawn wrapper. */
     methods: Map<string, {
         params: ParamShape[];
         ret: IrType;
         abstract?: true;
         async?: true;
+        gen?: {
+            yieldT: IrType;
+            nextT: IrType;
+        };
     }>;
     /** OWN GENERIC instance methods (own type parameters — `m<T>(x: T)`),
      * monomorphized per call site like top-level generic functions: instance
@@ -39,6 +52,16 @@ export interface ClassInfo {
      * generic twin of staticMethods (same this/super fence, same
      * through-a-VALUE shadowing rules via staticShadowBelow). */
     genericStatics?: Map<string, GenericFnInfo>;
+    /** DEFERRED-INIT fields (inherited included, like `fields`): a
+     * `stream!: T` definite-assignment assertion (or an SPI-off
+     * initializer-less field) whose first assignment happens past the
+     * constructor's top level. The SLOT is the undefined-armed union —
+     * allocation writes the interned undefined, exactly Node's
+     * pre-assignment read — writes wrap into the arm, and every READ is a
+     * CHECKED extraction back to the declared type: a genuinely
+     * unassigned read throws the catchable TypeError instead of yielding
+     * an undefined the declared type cannot hold (SEMANTICS.md). */
+    deferredInitFields?: Set<string>;
     /** null for the builtin error classes (runtime-provided; no source).
      * Class EXPRESSIONS carry their ts.ClassExpression here — members,
      * accessors, and locs read identically off either form. */
@@ -509,6 +532,10 @@ export declare function findMethodOn(L: Lowerer, info: ClassInfo | null, name: s
         ret: IrType;
         abstract?: true;
         async?: true;
+        gen?: {
+            yieldT: IrType;
+            nextT: IrType;
+        };
     };
 } | null;
 /** True when `sub` is a STRICT descendant of `sup` in the class graph. */
@@ -725,3 +752,8 @@ export declare function lowerNew(L: Lowerer, expr: ts.NewExpression): IrExpr;
    * this HALF of the accessor (get and set devirtualize independently),
    * a direct call of the nearest declaration otherwise. */
 export declare function accessorCall(L: Lowerer, className: string, member: string, obj: IrExpr, extraArgs: IrExpr[], ret: IrType, loc: SrcLoc): IrExpr;
+/** The generic function-like INITIALIZER behind a class FIELD —
+ * `time = async <T>(...) => {...}` or `= function g<T>(...) {...}`
+ * (parens stripped): bindingGenericFnNodeOf's shape rule, member form.
+ * Null when the field isn't that shape. */
+export declare function genericFieldFnNodeOf(member: ts.PropertyDeclaration): ts.FunctionExpression | ts.ArrowFunction | null;

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

@@ -6,7 +6,7 @@
 import * as ts from "../ts7/adapter.js";
 import { BOOL, DYN, F64, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, URL_T, VOID, arrayOf, isSupportedMapKey, isUnitType, typeEquals } from "../../ir/nodes.js";
 import { MAX_GENERIC_INSTANCES, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
-import { typeKey } from "../types.js";
+import { isGenericCallableMemberType, typeKey } from "../types.js";
 import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf } from "../program.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, newFnCtx, own } from "./lowerer.js";
 import { bufEncoding, lowerMapSeedArrayNew } from "./lower-containers.js";
@@ -833,29 +833,40 @@ mixin) {
         // `member.cls` backlink fills after the ClassInfo assembles below.
         const genericMethods = new Map();
         const genericStatics = new Map();
+        // Accepts generic METHODS and instance FIELDS initialized with a
+        // generic arrow/function expression (`time = async <T>(...) => {...}`
+        // — the field form of a generic method: no closure slot can hold a
+        // generic function, so the member collects aside like a method and
+        // calls dispatch statically per instantiation; the arrow's lexical
+        // `this` IS the instance, exactly the method's param 0). ASYNC
+        // members collect too: a generic async instance is an async
+        // IrFunction like any other (lowerGenericInstance), calls enter
+        // through the instance's own spawn wrapper, and no vtable slot is
+        // ever involved — generic members always dispatch statically.
         const collectGenericMember = (member, isStatic) => {
-            if (!ts.isIdentifier(member.name)) {
+            const fnNode = ts.isPropertyDeclaration(member)
+                ? genericFieldFnNodeOf(member)
+                : member;
+            if (!ts.isIdentifier(member.name) && !ts.isPrivateIdentifier(member.name)) {
                 L.unsupported("SC1090", member, "computed generic method names");
             }
-            if (member.asteriskToken)
+            if (fnNode.asteriskToken)
                 L.unsupported("SC1071", member);
-            if (member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
-                L.unsupported("SC1090", member, "async methods");
-            }
             const mName = member.name.text;
             const typeParams = [];
-            for (const tp of member.typeParameters) {
+            for (const tp of fnNode.typeParameters) {
                 const sym = L.checker.getSymbolAtLocation(tp.name);
                 if (!sym)
                     L.unsupported("SC1090", member, "this method form");
                 typeParams.push(sym);
             }
-            for (const param of member.parameters) {
-                if (!ts.isIdentifier(param.name))
+            for (const param of fnNode.parameters) {
+                if (!ts.isIdentifier(param.name) && !ts.isObjectBindingPattern(param.name) && !ts.isArrayBindingPattern(param.name)) {
                     L.unsupported("SC1031", param);
+                }
             }
             (isStatic ? genericStatics : genericMethods).set(mName, {
-                decl: member,
+                decl: fnNode,
                 baseName: mName,
                 qualifiedName: `%${className}.${isStatic ? "static:" : ""}${mName}`,
                 typeParams,
@@ -908,8 +919,17 @@ mixin) {
                 // exists, so the members that would need one — accessors, and
                 // initializer-less fields (undefined until someone assigns
                 // them) — keep the fence, each named at its use site.
+                // #PRIVATE statics ride along under their spelled names
+                // ('#count' → the module global %g.s.C.#count, '#make' → the
+                // module function %C.static:#make): tsc confines every access
+                // to the declaring class's body, and the resolution guard in
+                // findStaticOn's callers keeps a SUBCLASS-named receiver
+                // (`D.#s` — Node's brand TypeError) from resolving up the
+                // chain. Class-VALUE receivers fence for privates (a classval
+                // slot can hold a descendant at runtime, and only the declaring
+                // class object carries the brand in JS).
                 if (ts.isPropertyDeclaration(member) &&
-                    ts.isIdentifier(member.name) &&
+                    (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                     member.initializer &&
                     member.postfixToken?.kind !== ts.SyntaxKind.QuestionToken) {
                     const type = L.irTypeOf(member.name);
@@ -930,7 +950,7 @@ mixin) {
                 // function `%C.static:m` is an async IrFunction (fiber spawn
                 // wrapper), no vtable in sight — statics never dispatch.
                 if (ts.isMethodDeclaration(member) &&
-                    ts.isIdentifier(member.name) &&
+                    (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                     member.body &&
                     member.typeParameters === undefined &&
                     member.asteriskToken === undefined) {
@@ -938,13 +958,14 @@ mixin) {
                     staticMethods.set(member.name.text, { params: shapes, ret: ft.ret, member });
                 }
                 // GENERIC static methods monomorphize like top-level generic
-                // functions (`%C.static:m%n`); async ones keep the async-method
-                // use-site fence below.
+                // functions (`%C.static:m%n`), async ones included — a generic
+                // async instance is an async module function entered through its
+                // own spawn wrapper (the async-static precedent above, per
+                // instantiation).
                 if (ts.isMethodDeclaration(member) &&
-                    ts.isIdentifier(member.name) &&
+                    (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                     member.body &&
-                    member.typeParameters !== undefined &&
-                    !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
+                    member.typeParameters !== undefined) {
                     collectGenericMember(member, true);
                 }
                 // Statics that don't qualify for the module-global/module-
@@ -963,8 +984,28 @@ mixin) {
             // 7's ClassElement base carries no `name`; read it structurally
             // (every named member kind stores a PropertyName there).
             const memberName = member.name;
+            // #PRIVATE members compile: their names ('#m') are unspellable by
+            // any public identifier, so they ride the ordinary fields/methods
+            // maps collision-free — with the base-chain walks doubling as
+            // LEXICAL resolution because a subclass re-declaring an inherited
+            // private NAME is fenced here (JS would give the two classes
+            // DISTINCT private slots under one spelling; one name, one slot is
+            // the static story — rename one). tsc guarantees every access site
+            // sits inside the declaring class's body, and privates never
+            // enter vtables (no redeclaration below ⇒ overrideBelow is false
+            // ⇒ every call devirtualizes), which is exactly JS's semantics:
+            // lexically bound, no dynamic dispatch, a subclass cannot
+            // override.
             if (memberName && ts.isPrivateIdentifier(memberName)) {
-                L.unsupported("SC1090", member, "#private class members");
+                const pname = memberName.text;
+                if (base !== null &&
+                    (base.fields.has(pname) ||
+                        L.findMethodOn(base, pname) !== null ||
+                        L.findMethodOn(base, `get:${pname}`) !== null ||
+                        L.findMethodOn(base, `set:${pname}`) !== null ||
+                        findGenericMethodOn(L, base, pname) !== null)) {
+                    L.unsupported("SC1090", memberName, `redeclaring the private name '${pname}' of a base class (JS gives each class its own distinct '${pname}' slot; these layouts have one slot per name — rename one)`);
+                }
             }
             // The EventEmitter API surface is runtime-provided: a subclass
             // member with one of its names would shadow behavior the runtime
@@ -1029,8 +1070,45 @@ mixin) {
                     // get/set pair — declare the field and accessors explicitly.
                     L.unsupported("SC1090", member, "auto-accessor fields ('accessor x')");
                 }
-                if (!ts.isIdentifier(member.name))
+                // #private fields ride the ordinary field machinery — the '#'
+                // name is unspellable publicly, so the slot never collides, and
+                // enumeration surfaces (inspect) exclude it like Node.
+                if (!ts.isIdentifier(member.name) && !ts.isPrivateIdentifier(member.name)) {
                     L.unsupported("SC1090", member, "computed field names");
+                }
+                // A field initialized with a GENERIC arrow/function expression
+                // (`time = async <T>(label, fn) => {...}` — the Output.time
+                // idiom): a generic MEMBER, not a field. No closure slot can
+                // hold a generic function (the record-shape exclusion rule), so
+                // the member collects like a generic method — no field slot,
+                // static per-instantiation dispatch, `this` as param 0 (the
+                // arrow's lexical `this` IS the instance). Reads of the field as
+                // a VALUE and writes to it fence at their sites — there is no
+                // slot — which enforces never-reassigned by construction.
+                // Guarded on the member TYPE still carrying its type parameters:
+                // an annotation that pins a concrete signature makes an ordinary
+                // closure field, which the normal path below owns.
+                if (genericFieldFnNodeOf(member) !== null &&
+                    isGenericCallableMemberType(L.typeOf(member.name), L.checker)) {
+                    if (fields.has(member.name.text)) {
+                        L.unsupported("SC1090", member.name, "redeclaring inherited fields");
+                    }
+                    if (L.findMethodOn(base, member.name.text)) {
+                        L.unsupported("SC1090", member.name, "fields shadowing inherited methods");
+                    }
+                    if (findGenericMethodOn(L, base, member.name.text)) {
+                        L.unsupported("SC1090", member.name, `redeclaring the inherited generic member '${member.name.text}' (generic members dispatch statically, so the base's call sites could never reach this redeclaration)`);
+                    }
+                    collectGenericMember(member, false);
+                    continue;
+                }
+                // Non-generic fields shadowing an inherited GENERIC member split
+                // the two dispatch worlds (static per-instantiation calls would
+                // never see the field's value) — the method-vs-generic mixing
+                // fence, field form.
+                if (findGenericMethodOn(L, base, member.name.text)) {
+                    L.unsupported("SC1090", member.name, `fields shadowing the inherited generic member '${member.name.text}' (generic members dispatch statically and would never reach this field's value)`);
+                }
                 // OPTIONAL fields (`a?: string`) are the record-field precedent
                 // applied to class shapes: the checker already types the slot
                 // `string | undefined`, the allocation writes the interned
@@ -1046,7 +1124,26 @@ mixin) {
                     L.unsupported("SC1090", member.name, "'unknown'-typed class fields");
                 }
                 if (fields.has(member.name.text)) {
-                    L.unsupported("SC1090", member.name, "redeclaring inherited fields");
+                    // REDECLARING an inherited field: Node [[Define]]s the OWN
+                    // property again when THIS class's field initializers run
+                    // (after super()), so the base slot simply takes the new
+                    // value at that position — a slot-type-exact redeclare WITH
+                    // an initializer lowers as an assignment into the inherited
+                    // slot, no new slot, no layout change (the `class
+                    // ConfigError extends Error { name = "ConfigError" }`; the
+                    // builtin Error prefix included — reads, toString, and throw
+                    // reports all answer the overwritten name like Node). A BARE
+                    // redeclare writes undefined in Node (`class B extends A
+                    // { x; }` reads undefined!) and a type-changing redeclare has
+                    // no single slot type — both keep the fence.
+                    const baseType = fields.get(member.name.text);
+                    if (member.initializer && typeEquals(type, baseType)) {
+                        fieldOrder.push({ name: member.name.text, type, initializer: member.initializer, redeclared: true });
+                        continue;
+                    }
+                    L.unsupported("SC1090", member.name, member.initializer
+                        ? "redeclaring inherited fields at a different type"
+                        : "redeclaring inherited fields without an initializer (Node resets the field to undefined)");
                 }
                 if (L.findMethodOn(base, member.name.text)) {
                     L.unsupported("SC1090", member.name, "fields shadowing inherited methods");
@@ -1154,11 +1251,22 @@ mixin) {
                 const mName = classMemberNameOf(L, member.name);
                 if (mName === null)
                     L.unsupported("SC1090", member, "computed method names");
-                // Generator METHODS stay fenced (virtualCall dispatch over
-                // gen-spawn wrappers has no story yet); module-level function*
-                // and object-literal *methods compile.
-                if (member.asteriskToken !== undefined) {
-                    L.unsupported("SC1071", member, "generator methods (declare a module-level function* and call it from the method)");
+                // PUBLIC generator METHODS stay fenced (virtualCall dispatch
+                // over gen-spawn wrappers has no story yet); module-level
+                // function* and object-literal *methods compile — and #PRIVATE
+                // generator methods (`*#walk()`) compile below: privates never
+                // enter vtables (a subclass redeclaration is fenced, so
+                // overrideBelow can never flip), every call is a direct call the
+                // emitter routes through the gen-spawn wrapper with `this` as
+                // param 0 — the async-method precedent, generator form.
+                if (member.asteriskToken !== undefined && !ts.isPrivateIdentifier(member.name)) {
+                    L.unsupported("SC1071", member, "generator methods (a #private generator method compiles — privates never dispatch dynamically; or declare a module-level function* and call it from the method)");
+                }
+                // An async #private generator (`async *#m()`) is still an async
+                // generator — the blanket SC1071 fence.
+                if (member.asteriskToken !== undefined &&
+                    member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
+                    L.unsupported("SC1071", member, "async generators (async function*)");
                 }
                 // An ABSTRACT method is a signature with no body — type-world,
                 // except that it declares the vtable slot: calls through
@@ -1302,7 +1410,18 @@ mixin) {
                 if (overridden && (asyncMember || overridden.sig.async === true)) {
                     L.unsupported("SC1090", member.name, `overriding ${overridden.sig.async === true ? "the async method" : "a method with an async method"} '${mName}' (async methods dispatch statically — the vtable slot machinery has no fiber-spawn story)`);
                 }
-                methods.set(mName, asyncMember ? { params: shapes, ret: ft.ret, async: true } : { params: shapes, ret: ft.ret });
+                // A #private GENERATOR method carries its channels on the sig:
+                // the body lowers as a generator IrFunction (`this` as param 0),
+                // and every call — direct by construction — enters through the
+                // emitted gen-spawn wrapper, answering the suspended generator.
+                if (member.asteriskToken !== undefined) {
+                    if (ft.ret.kind !== "generator")
+                        L.badType(member.name, L.typeOf(member.name));
+                    methods.set(mName, { params: shapes, ret: ft.ret, gen: { yieldT: ft.ret.yieldT, nextT: ft.ret.nextT } });
+                }
+                else {
+                    methods.set(mName, asyncMember ? { params: shapes, ret: ft.ret, async: true } : { params: shapes, ret: ft.ret });
+                }
                 // Overrides keep the inherited ABI exactly, so only non-override
                 // methods may still refine once the ctor scan runs.
                 if (ft.ret.kind === "dyn" && !overridden) {
@@ -1317,7 +1436,9 @@ mixin) {
                 // whole-program devirtualization, vtable slots, may-throw) then
                 // applies verbatim, with the get and set halves independent.
                 const isGet = ts.isGetAccessor(member);
-                if (!ts.isIdentifier(member.name)) {
+                // #private accessors collect as "get:#x"/"set:#x" — the same
+                // reserved spelling, one more unspellable segment.
+                if (!ts.isIdentifier(member.name) && !ts.isPrivateIdentifier(member.name)) {
                     L.unsupported("SC1090", member, "computed accessor names");
                 }
                 // ABSTRACT accessors are the abstract-method story with property
@@ -1395,6 +1516,7 @@ mixin) {
         // (conditional branches, assignment in a method, no constructor at
         // all) leaves a window where Node reads undefined and these layouts
         // would read zeroed memory, so it fences instead.
+        const deferredInitFields = new Set(base?.deferredInitFields ?? []);
         if (unguardedFields.length > 0) {
             const topAssigned = new Set();
             for (const stmt of ctor?.body?.statements ?? []) {
@@ -1407,8 +1529,32 @@ mixin) {
                 }
             }
             for (const f of unguardedFields) {
-                if (!topAssigned.has(f.name))
-                    L.unsupported("SC1090", f.node, f.why);
+                if (topAssigned.has(f.name))
+                    continue;
+                // DEFERRED INITIALIZATION (the Output.initialize idiom —
+                // `stream!: T` assigned inside a method the constructor calls):
+                // the slot becomes the undefined-armed union — allocation writes
+                // the interned undefined (Node's pre-assignment value), writes
+                // wrap, and reads CHECKED-extract the declared type, trapping a
+                // genuinely-unassigned read with the catchable TypeError.
+                // Only single-arm declared types take the deferral (the checked
+                // extraction targets one arm); union-typed `!` fields keep the
+                // fence.
+                const declared = fields.get(f.name);
+                const armable = declared !== undefined && !isUnitType(declared) &&
+                    declared.kind !== "union" && declared.kind !== "jsval" && declared.kind !== "dyn" &&
+                    declared.kind !== "map" && declared.kind !== "generator" && declared.kind !== "void" &&
+                    declared.kind !== "caught";
+                const armed = armable ? L.withUndefinedArm(declared) : null;
+                if (armed !== null && armed.kind === "union") {
+                    fields.set(f.name, armed);
+                    const fo = fieldOrder.find((x) => x.name === f.name);
+                    if (fo)
+                        fo.type = armed;
+                    deferredInitFields.add(f.name);
+                    continue;
+                }
+                L.unsupported("SC1090", f.node, f.why);
             }
         }
         // Partial overrides of an inherited accessor pair. JS gives the
@@ -1672,9 +1818,11 @@ mixin) {
                 ...(base ? { base: base.def.name } : {}),
                 // Layout order: the base chain's fields as an IDENTICAL prefix,
                 // then this class's own — what makes an upcast a reinterpret.
+                // Redeclared INHERITED fields contribute no slot (their
+                // initializers assign the prefix slot).
                 fields: [
                     ...(base?.def.fields ?? []),
-                    ...fieldOrder.map((f) => ({ name: f.name, type: f.type })),
+                    ...fieldOrder.filter((f) => f.redeclared !== true).map((f) => ({ name: f.name, type: f.type })),
                 ],
                 ...(methods.size > 0 ? { methods: [...methods.keys()] } : {}),
                 ...(abstractClass ? { abstract: true } : {}),
@@ -1700,6 +1848,7 @@ mixin) {
             ...(staticBlocks.length > 0 ? { staticBlocks } : {}),
             ...(symbolFields.size > 0 ? { symbolFields } : {}),
             ...(classDecoratorNodes.length > 0 ? { classDecorators: { nodes: classDecoratorNodes } } : {}),
+            ...(deferredInitFields.size > 0 ? { deferredInitFields } : {}),
         };
         // GENERIC members get their declaring-class backlink now that the
         // info exists (instance lowering reads it for `this` typing and the
@@ -2324,6 +2473,13 @@ export function lowerStaticFieldRead(L, expr) {
         return null;
     const loc = locOf(expr);
     const found = findStaticOn(L, info, expr.name.text);
+    // A #private static resolves only through the DECLARING class's own
+    // name: in JS the brand lives on that one constructor object, so
+    // `D.#s` (a subclass receiver) throws Node's TypeError instead of
+    // reaching up the chain — fenced rather than silently resolved.
+    if (found && expr.name.text.startsWith("#") && found.declarer !== info) {
+        L.unsupported("SC1090", expr, `reading the private static '${expr.name.text}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
+    }
     if (found?.field !== undefined) {
         return L.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
     }
@@ -2648,7 +2804,17 @@ export function lowerStaticMethodCall(L, call, access) {
 }
 function staticCallOn(L, call, access, info, throughValue) {
     const loc = locOf(call);
+    // #private statics: through-a-VALUE receivers fence (a classval slot
+    // can hold a descendant at runtime and only the declaring class
+    // object carries the brand in JS), and the direct spelling resolves
+    // only on the declaring class itself — `D.#s` is Node's TypeError.
+    if (access.name.text.startsWith("#") && throughValue) {
+        L.unsupported("SC1090", call, `calling the private static '${access.name.text}' through a class value (JS brands the declaring class object alone — call it through the class's own name)`);
+    }
     const found = findStaticOn(L, info, access.name.text);
+    if (found && access.name.text.startsWith("#") && found.declarer !== info) {
+        L.unsupported("SC1090", call, `calling the private static '${access.name.text}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
+    }
     if (!found) {
         // GENERIC static methods: monomorphized like top-level generic
         // functions, called directly as `%C.static:m%n` — with the same
@@ -2731,6 +2897,14 @@ export function lowerClassValueProperty(L, expr) {
     if (!found) {
         L.unsupported("SC1090", expr, `the static member '${member}' of class '${info.def.name.replace(/^%|^%m\d+\./, "")}' (static accessors and initializer-less static fields have no lowering, and Function members like .call/.bind/.prototype have no value form)`);
     }
+    // #private statics never read through class VALUES: the slot can hold
+    // a descendant at runtime and JS brands the declaring class object
+    // alone (Node's TypeError on any other receiver). The direct
+    // class-name spelling resolved in lowerStaticFieldRead, so a private
+    // reaching here is a classval-typed binding.
+    if (member.startsWith("#")) {
+        L.unsupported("SC1090", expr, `reading the private static '${member}' through a class value (JS brands the declaring class object alone — spell the declaring class's name)`);
+    }
     if (staticShadowBelow(L, info, member)) {
         L.unsupported("SC1090", expr, `reading the static member '${member}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
     }
@@ -3091,6 +3265,10 @@ function lowerClassCtorInner(L, info) {
 export function classMemberNameOf(L, name) {
     if (ts.isIdentifier(name))
         return name.text;
+    // #private methods key by their spelled name ('#m') — '#' is
+    // unspellable in public identifiers, the accessor-colon precedent.
+    if (ts.isPrivateIdentifier(name))
+        return name.text;
     if (!ts.isComputedPropertyName(name))
         return null;
     let e = name.expression;
@@ -3305,7 +3483,7 @@ export function lowerClassMethodMember(L, info, fnLike) {
 function lowerClassMethodMemberInner(L, info, fnLike) {
     const className = info.def.name;
     const thisType = { kind: "object", className };
-    const memberName = ts.isMethodDeclaration(fnLike) ? classMemberNameOf(L, fnLike.name) : ts.isIdentifier(fnLike.name) ? fnLike.name.text : null;
+    const memberName = ts.isMethodDeclaration(fnLike) ? classMemberNameOf(L, fnLike.name) : ts.isIdentifier(fnLike.name) || ts.isPrivateIdentifier(fnLike.name) ? fnLike.name.text : null;
     if (memberName === null)
         return null;
     const mName = ts.isMethodDeclaration(fnLike)
@@ -3323,9 +3501,21 @@ function lowerClassMethodMemberInner(L, info, fnLike) {
     // spawn's argument pack). Dispatch is static by construction — the
     // override fence at collection keeps async methods out of vtables.
     const isAsync = sig.async === true && sig.ret.kind === "promise";
-    const bodyReturn = isAsync && sig.ret.kind === "promise" ? sig.ret.inner : sig.ret;
+    // #PRIVATE GENERATOR methods: the module function is a generator
+    // IrFunction — the body returns the TReturn channel, yields ride
+    // ctx.generator, and every call (direct by construction — privates
+    // never virtualize) enters through the emitted gen-spawn wrapper with
+    // `this` in the argument pack, answering the suspended generator.
+    const genCh = sig.gen !== undefined && sig.ret.kind === "generator" ? sig.gen : null;
+    const bodyReturn = isAsync && sig.ret.kind === "promise"
+        ? sig.ret.inner
+        : genCh !== null
+            ? L.genBodyReturnType(sig.ret)
+            : sig.ret;
     const fnCtx = newFnCtx(false, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
+    if (genCh !== null)
+        fnCtx.generator = genCh;
     L.fnStack.push(fnCtx);
     try {
         const thisLocal = L.declareThis(thisType);
@@ -3345,6 +3535,8 @@ function lowerClassMethodMemberInner(L, info, fnLike) {
         };
         if (isAsync)
             fn.async = true;
+        if (genCh !== null)
+            fn.generator = genCh;
         return fn;
     }
     finally {
@@ -4001,7 +4193,7 @@ export function lowerNew(L, expr) {
                 (isModuleExportsAccess(expr.expression.expression) ||
                     (ts.isIdentifier(expr.expression.expression) &&
                         expr.expression.expression.text === "exports" &&
-                        !L.resolveLocal(expr.expression.expression) &&
+                        !L.peekLocal(expr.expression.expression) &&
                         !L.globalOf(expr.expression.expression)))) ||
                 L.cjsLocalModuleBindingOf(expr.expression.expression))) {
             // Candidate symbols for the export global: the member symbol as
@@ -4369,7 +4561,22 @@ export function lowerNew(L, expr) {
                 if (!ts.isSpreadElement(argNode)) {
                     const argIr = L.mapTypeOf(L.typeOf(argNode));
                     if (argIr?.kind === "array" && typeEquals(argIr.elem, mapped.elem)) {
-                        return { kind: "setNew", seed: L.lowerExpr(argNode), type: mapped, loc };
+                        let seed = L.lowerExpr(argNode);
+                        // A T[]-DECLARED seed whose value is an island handle (a
+                        // package's exported array — the binding never held a
+                        // static array): the VALIDATED exit copies the engine
+                        // array out (strict elements, the catchable TypeError on a
+                        // lying handle), and the bulk add proceeds on the copy —
+                        // construction reads the seed once, so the aliasing
+                        // divergence has nothing to observe.
+                        if (seed.type.kind === "jsval" && L.boundaryExitSafe(arrayOf(mapped.elem))) {
+                            seed = { kind: "jsExit", value: seed, type: arrayOf(mapped.elem), loc: seed.loc };
+                        }
+                        if (typeEquals(seed.type, arrayOf(mapped.elem))) {
+                            return { kind: "setNew", seed, type: mapped, loc };
+                        }
+                        // Any other lowered kind falls through to the named fence
+                        // below — never a mistyped seed into the validator.
                     }
                 }
             }
@@ -4698,4 +4905,20 @@ export function accessorCall(L, className, member, obj, extraArgs, ret, loc) {
         loc,
     };
 }
+/** The generic function-like INITIALIZER behind a class FIELD —
+ * `time = async <T>(...) => {...}` or `= function g<T>(...) {...}`
+ * (parens stripped): bindingGenericFnNodeOf's shape rule, member form.
+ * Null when the field isn't that shape. */
+export function genericFieldFnNodeOf(member) {
+    if (member.initializer === undefined)
+        return null;
+    let init = member.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if ((ts.isArrowFunction(init) || ts.isFunctionExpression(init)) &&
+        init.typeParameters !== undefined && init.body !== undefined) {
+        return init;
+    }
+    return null;
+}
 //# sourceMappingURL=lower-classes.js.map