@geastack/compiler 1.0.15

package/dist/targets/cpp/captures.js

@@ -0,0 +1,269 @@
+import { ownershipOf } from '../../representation/model.js';
+import { currentCppRuntimeCapabilities } from './manifest.js';
+import { cppTypeOf } from './types.js';
+/**
+ * Which functions capture, and whether each capture is safe to transport.
+ *
+ * The walk itself -- which declaration each body reads or writes whose cell
+ * some OTHER frame owns, the transitive closure over allocation edges, and
+ * which of those cells must be boxed -- is `ir/captures.ts`'s
+ * `computeCaptureFacts`/`publishCaptureFacts`, run once over the whole
+ * program and published onto each body as `IrBody.facts`
+ * (a program fact; the target is a printer and computes none of its own). This module used to
+ * recompute all of that itself from the same bodies and placements at render
+ * time; what is left here is the part that is genuinely target-specific: the
+ * carrier-ownership ADMISSION decision against `currentCppRuntimeCapabilities`
+ * (`isAdmittedOwnership`), and turning an admitted set of declarations into
+ * the `CaptureLayout`/`CaptureSlot` shape the emitter reads
+ * (`admissionForBody`).
+ */
+/**
+ * Whether this backend's runtime manifest actually supports the ownership
+ * class `representation/model.ts`'s `ownershipOf` names for a carrier -- a target-
+ * specific admission decision against `currentCppRuntimeCapabilities`, kept
+ * apart from the (representation-only) classification itself.
+ */
+const isAdmittedOwnership = (representation) => {
+    const ownership = ownershipOf(representation);
+    return ownership !== null && currentCppRuntimeCapabilities.captureOwnershipSupport.has(ownership);
+};
+/**
+ * One capturing function's environment, or the precise reason it cannot have
+ * one -- built from `IrBodyFacts.capturedDeclarations`/`.capturedReceiver`
+ * (`ir/captures.ts`'s transitive closure over allocation edges, published
+ * once onto the body) plus the whole-program `boxed` fact.
+ *
+ * `boxed` alone decides the aliasing question: it is exactly the union of
+ * "reassigned somewhere in the program", "holds the very closure capturing
+ * it" and "captured before any owning-frame write dominates the allocation"
+ * (`ir/captures.ts`'s `computeCaptureFacts`), so a declaration this loop
+ * finds NOT boxed can be none of those three -- there is no separate
+ * reassigned/self-reference branch to fall through to below the boxed one.
+ */
+const admissionForBody = (captured, receiverUse, placements, boxed) => {
+    const slots = [];
+    let receiver = null;
+    let refusal = null;
+    for (const declaration of captured) {
+        const placement = placements.get(declaration);
+        if (!placement)
+            continue;
+        if (refusal)
+            continue; // Already refused; the first reason found is the one reported.
+        if (boxed.has(declaration)) {
+            // Shared by aliasing, not by copying: `ir/captures.ts` has already
+            // decided (whole-program) that this exact declaration is reassigned
+            // after some closure captures it, or holds the very closure capturing
+            // it, or is captured before an owning write dominates the allocation,
+            // and that a plain value copy would therefore be wrong -- see
+            // `IrBodyFacts.boxed`. What this slot carries is a `std::shared_ptr`
+            // handle to the one heap cell every frame touching the declaration
+            // aliases, and copying a handle is always safe regardless of what the
+            // declaration's own representation's ownership tier says.
+            if (!placement.representation || placement.representation.kind === 'unresolved') {
+                refusal = `${declaration} is captured but the representation plan selected no carrier for it`;
+                continue;
+            }
+            slots.push({ declaration, representation: placement.representation, boxed: true });
+            continue;
+        }
+        if (!placement.representation) {
+            refusal = `${declaration} is captured but the representation plan selected no carrier for it`;
+            continue;
+        }
+        if (!isAdmittedOwnership(placement.representation)) {
+            const ownership = ownershipOf(placement.representation);
+            refusal = ownership
+                ? `${declaration} is captured but carries "${placement.representation.kind}" with ${ownership} ownership, which this backend's capture support does not admit`
+                : `${declaration} is captured but carries "${placement.representation.kind}", which has no ownership this backend can prove a copy stays safe under`;
+            continue;
+        }
+        slots.push({ declaration, representation: placement.representation, boxed: false });
+    }
+    // A body with no receiver of its own that nonetheless needs one either
+    // reads `this` directly (the `lower-operands.ts` capture fallback: an
+    // ordinary method's `this` read inside a nested arrow, lowered as a
+    // capture of the enclosing frame's receiver) or merely relays it -- it
+    // allocates some nested closure that reads `this` several frames deeper,
+    // without ever naming `this` itself. `receiverUse` already carries
+    // whichever of those is true, propagated by `ir/captures.ts`'s `transitiveCaptures` exactly
+    // the way `captured` above propagates an ordinary declaration outward
+    // through every relay frame; a body that owns its receiver contributes
+    // `null` to that propagation regardless of what its own operations name,
+    // which is why this check does not need to repeat `declaresOwnReceiver`.
+    if (!refusal && receiverUse !== null) {
+        if (!isAdmittedOwnership(receiverUse)) {
+            const ownership = ownershipOf(receiverUse);
+            refusal = ownership
+                ? `the enclosing method's receiver is captured but carries ${ownership} ownership, which this backend's capture support does not admit`
+                : `the enclosing method's receiver is captured but carries "${receiverUse.kind}", which has no ownership this backend can prove a copy stays safe under`;
+        }
+        else {
+            receiver = receiverUse;
+        }
+    }
+    if (refusal)
+        return { kind: 'refused', reason: refusal };
+    if (slots.length === 0 && receiver === null)
+        return { kind: 'none' };
+    const layout = { slots, receiver };
+    return { kind: 'ok', layout };
+};
+/**
+ * Every capturing function's environment, computed once for the whole
+ * translation unit.
+ *
+ * The walk that used to live here -- which declaration each body reads or
+ * writes whose cell some other frame owns, the transitive closure over
+ * allocation edges, which cells are reassigned/self-referential/captured
+ * before their owning write, and which of those must therefore be boxed --
+ * is now `ir/captures.ts`'s `computeCaptureFacts`, run once over the whole
+ * program and published onto each body as `IrBody.facts`
+ * (a program fact; the target is a printer and computes none of its own). This function reads those
+ * facts back off the bodies it is handed instead of recomputing them: it
+ * only reunites the whole-program `boxed`/`requiresEarlyBox` sets (published
+ * per OWNING body, per `IrBodyFacts.boxed`'s doc comment) and turns each
+ * capturing body's own `capturedDeclarations`/`capturedReceiver` into the
+ * `CaptureAdmission` the emitter reads.
+ *
+ * Only a function that is actually allocated as a value (`allocate-callable`
+ * somewhere in the program names it -- `IrBodyFacts.allocatedAsValue`) gets
+ * an entry: a method's own body can read a cell owned by an enclosing frame
+ * in principle, but a method is never itself wrapped in a `CallableObject`
+ * with an environment slot to populate -- it is called directly, by name --
+ * so there is nowhere for such a capture to be transported *from*. That case
+ * has no admission here and falls through to `bindingReference`'s
+ * pre-existing "capture path... not installed" refusal, which is the
+ * correct, honest answer for it today.
+ *
+ * ...with one exception, and it is an exception because the transport EXISTS
+ * for it: a record's ACCESSOR body. `get current() { return n + 1 }` written
+ * inside a function reads that function's local, and the object the accessor
+ * is reached through is allocated in that very frame -- so the object can
+ * carry the environment, one `gea::PackedEnvironment` member per capturing
+ * half (`cppRecordAccessorEnvironmentName`), populated at the allocation and
+ * handed back at every call. `capturingAccessors` names those bodies;
+ * admitting one that captures NOTHING would add an environment formal no
+ * caller supplies, so the capture set is what qualifies it, not the fact that
+ * it is an accessor.
+ */
+export const buildCaptureIndex = (bodies, placements, capturingAccessors = new Set()) => {
+    const boxedDeclarations = new Set();
+    const requiresEarlyBoxDeclarations = new Set();
+    const capturedDeclarations = new Set();
+    const bodyBySourceOwner = new Map();
+    for (const body of bodies) {
+        bodyBySourceOwner.set(body.sourceOwner, body);
+        for (const declaration of body.facts?.boxed ?? [])
+            boxedDeclarations.add(declaration);
+        for (const declaration of body.facts?.requiresEarlyBox ?? [])
+            requiresEarlyBoxDeclarations.add(declaration);
+        for (const declaration of body.facts?.capturedDeclarations ?? [])
+            capturedDeclarations.add(declaration);
+    }
+    const admissions = new Map();
+    for (const body of bodies) {
+        const facts = body.facts;
+        if (!facts)
+            continue;
+        const accessorCarriesEnvironment = !facts.allocatedAsValue && capturingAccessors.has(body.sourceOwner) && facts.capturedDeclarations.length > 0;
+        if (!facts.allocatedAsValue && !accessorCarriesEnvironment)
+            continue;
+        admissions.set(body.sourceOwner, admissionForBody(facts.capturedDeclarations, facts.capturedReceiver, placements, boxedDeclarations));
+    }
+    return {
+        of: (owner) => admissions.get(owner) ?? { kind: 'none' },
+        isBoxed: (declaration) => boxedDeclarations.has(declaration),
+        isCaptured: (declaration) => capturedDeclarations.has(declaration),
+        requiresEarlyBox: (declaration) => requiresEarlyBoxDeclarations.has(declaration),
+        readsReceiver: (owner) => bodyBySourceOwner.get(owner)?.facts?.readsReceiver ?? false
+    };
+};
+/**
+ * Module-level function cells whose call can be spelled by NAME.
+ *
+ * `function makeAdder(base) {...}` becomes a cell holding a `CallableObject`,
+ * and every call to it -- from any body in the unit -- goes through that
+ * carrier's function pointer. For a callable whose identity is a runtime fact
+ * that indirection is the whole point; for a `function` declaration nothing
+ * ever reassigns it is pure loss, and it is the expensive kind: an indirect
+ * call is not inlinable, so the body stays opaque and every optimization that
+ * would have followed it -- constant propagation into it, and the
+ * devirtualization of a closure it RETURNS -- is lost with it. `closure`'s
+ * hot loop is two such calls and nothing else.
+ *
+ * Written exactly once is the whole condition, and it is the same arithmetic
+ * `buildCaptureIndex` uses for a reassignment: a declaration the program ever
+ * writes again has more than one `binding-write`, because the initializer and
+ * every later assignment lower to the same operation. A cell written once with
+ * a callable that captures nothing therefore holds that one body forever, and
+ * naming it is not an optimization the program could observe -- the carrier is
+ * still built wherever anything stores one.
+ *
+ * Deliberately NOT extended to a captured closure: its body reads state out of
+ * the environment pointer, which only the carrier has.
+ */
+export const buildDirectCallableIndex = (bodies, captures, placements) => {
+    const allocated = new Map();
+    const writeCounts = new Map();
+    const writtenCallable = new Map();
+    const writtenCarriers = new Map();
+    for (const body of bodies) {
+        for (const block of body.blocks.values()) {
+            for (const operation of block.operations) {
+                if (operation.kind !== 'allocate-callable')
+                    continue;
+                if (captures.of(operation.functionId).kind !== 'none')
+                    continue;
+                allocated.set(operation.result.id, operation.functionId);
+            }
+        }
+    }
+    for (const body of bodies) {
+        for (const block of body.blocks.values()) {
+            for (const operation of block.operations) {
+                if (operation.kind !== 'binding-write')
+                    continue;
+                writeCounts.set(operation.declaration, (writeCounts.get(operation.declaration) ?? 0) + 1);
+                const functionId = allocated.get(operation.value.value);
+                if (functionId !== undefined) {
+                    writtenCallable.set(operation.declaration, functionId);
+                    writtenCarriers.set(operation.declaration, operation.value.representation);
+                }
+            }
+        }
+    }
+    const direct = new Map();
+    for (const [declaration, functionId] of writtenCallable) {
+        if (writeCounts.get(declaration) !== 1)
+            continue;
+        // The cell and the function it holds can disagree about the CONVENTION
+        // even when the language calls them the same function: `const mergePath:
+        // (...paths: string[]) => string = (base?, sub?, ...rest) => ...` (hono's
+        // `utils/url.ts`) declares one rest parameter at position 0 and holds a
+        // body taking two optionals and its own rest at position 2. A call site
+        // packs its arguments the way the CELL says, so naming the body directly
+        // would hand a one-argument call to a three-parameter definition.
+        //
+        // The carrier is where the two conventions are reconciled -- storing the
+        // body in the cell adapts it (`gea_runtime.h`'s `spreadRestOverLeading`)
+        // -- so a disagreeing pair keeps the indirection it needs rather than
+        // being refused or, worse, called through the wrong signature.
+        const cell = placements.get(declaration)?.representation;
+        const held = writtenCarriers.get(declaration);
+        if (cell && held && cppTypeOf(cell) !== cppTypeOf(held))
+            continue;
+        direct.set(declaration, functionId);
+    }
+    return direct;
+};
+// The move pipeline that used to live here -- `buildDyingArgumentIndex`,
+// `ownedDyingValuesOf`, `ownedFormalInputsOf` -- is `ir/transfer.ts` now. It
+// reasons only about the lowered IR, never about how this target renders
+// anything, so the `IrOperand.transfer` fact
+// step moved it out from beside the printer.
+//
+// `buildRepeatedConstructorIndex` moved the same way, to `ir/program-facts.ts`:
+// whether a construction runs repeatedly is a question about the lowered IR's
+// own control flow and call graph, not about C++ text, so it belongs beside
+// the rest of that module's whole-program indices rather than here.

package/dist/targets/cpp/class-layout.d.ts

@@ -0,0 +1,313 @@
+import type { DeclarationId, FunctionId, IrValueId } from '../../identity/ids.js';
+import type { GetOperation, IrBody, IrOperand } from '../../ir/model.js';
+import type { CaptureIndex, EmitContext } from './emit-context.js';
+import type { ClassField, ClassLayout, ClassMethod } from '../../projection/classes.js';
+import { classFamilyOverridesOf } from '../../projection/dispatch.js';
+export { classFamilyOverridesOf };
+import { classMemberOf, classStaticMemberOf, type ClassMemberSite } from '../../projection/fields.js';
+export { classMemberOf, classStaticMemberOf, type ClassMemberSite };
+import { type RecordField, type Representation } from '../../representation/model.js';
+import { type ConversionSite } from './emit-narrowing.js';
+/**
+ * Reading a `ClassLayout` the way the language reads a class: down the
+ * inheritance chain, and with a base's own initialization kept the base's.
+ *
+ * Both functions here exist because a derived class is not a self-contained
+ * description of its instances. `ClassLayout` states only what a class declares
+ * itself (`projection/classes.ts`), which is the honest thing for it to state,
+ * and it names its base -- so anything that needs the *whole* object has to
+ * walk. Doing that walk in one place is what keeps a member lookup and a
+ * construction from disagreeing about which class owns what.
+ */
+/**
+ * The statements one class's own field initializers perform.
+ *
+ * Shared between the two places a class's fields are initialized, which are the
+ * same event seen from two sides: a base construction runs them itself, and a
+ * derived constructor runs them at its `super(...)` -- the language's order,
+ * after the base chain has returned and before the next statement of the
+ * derived constructor. Writing the sequence once means those two sites cannot
+ * drift into initializing a class differently depending on how it was reached.
+ *
+ * `fields` is the class's *own* declared fields, never a base's: a base
+ * initializes its own, and running them again from a derived construction would
+ * overwrite whatever the base's constructor body had already stored there.
+ */
+export declare const cppFieldInitializerStatements: (site: ConversionSite, 
+/**
+ * The class whose OWN fields these are -- not `ClassField.declaration`,
+ * which names the property declaration's own identity, not the class that
+ * declares it. `layout.declaration` at every call site.
+ */
+classDeclaration: DeclarationId, fields: readonly ClassField[], receiver: string, storedFieldOf: (field: ClassField) => Pick<RecordField, "value" | "required"> | null) => readonly string[] | string;
+/**
+ * A class field whose initializer is an arrow/function-expression literal
+ * capturing nothing but (optionally) its own receiver -- the "lazily
+ * materialized arrow-function class field" design: almost every real use of
+ * such a field is a direct call (`c.json(...)`), never a value read, so
+ * building its `CallableObject` -- one heap environment plus one identity --
+ * in every construction is waste this field's storage can defer instead.
+ *
+ * `initializer` is `ClassField.initializer`, the ECMA-262 `[[Initializer]]`
+ * thunk (`ClassFieldDefinitionRecord`'s own function, distinct from the arrow
+ * literal's body: see `censusLazyArrowFields`'s comment) -- the same FunctionId
+ * `cppFieldInitializerStatements` already calls with the receiver today. A
+ * qualifying field's storage starts empty (`invoke == nullptr`, the same
+ * zero-initialized default a field with NO initializer already gets) and
+ * every read -- `emit-properties.ts`'s `lazyMaterializedFieldReadText` -- calls
+ * this SAME thunk once, on demand, instead.
+ */
+export interface LazyArrowFieldPlan {
+    readonly initializer: FunctionId;
+    /**
+     * The arrow/function-expression literal's OWN body -- the `allocate-callable`
+     * target this census finds inside `initializer`'s thunk, and the only
+     * FunctionId a materialized instance of this field's `CallableObject` ever
+     * runs. A DIRECT call on an unmaterialized field (`emit-callable.ts`'s
+     * lazy-field call fusion) invokes this body itself, bypassing `initializer`
+     * -- and the `CallableObject`/environment it would otherwise have built --
+     * entirely.
+     */
+    readonly body: FunctionId;
+    /**
+     * Whether `body`'s own C++ signature takes a leading environment pointer,
+     * exactly `translation-unit.ts`'s `thunkOf`'s own `hasEnvironment =
+     * admission.kind === 'ok'` -- true even here, where the environment carries
+     * nothing but the captured receiver. A direct call supplies `nullptr` for
+     * it: `censusLazyArrowFields` admits only a body whose one capture is the
+     * receiver, which travels as its own leading argument instead (see
+     * `bodyReceiverRepresentation`), so the body never reads the pointer.
+     */
+    readonly bodyHasEnvironment: boolean;
+    /**
+     * The receiver `body` expects as a physical argument, or `null` for a body
+     * that takes none.
+     *
+     * An arrow closes over its enclosing `this` LEXICALLY -- it is never the
+     * body's own declared receiver, so `body`'s own `CallableAbi.receiver` is
+     * always `null` here, the same as any other arrow's. This is instead
+     * `captures.of(body).layout.receiver`, the exact representation
+     * `translation-unit.ts`'s `thunkOf` reads to populate the captured-receiver
+     * environment field it forwards as the thunk's own `gea_this` argument.
+     * Kept apart from `body`'s own ABI so a direct call can tell "no receiver
+     * travels" from "the receiver travels, just not as part of the semantic
+     * ABI" -- the same distinction `EmitContext.directCallReceivers` exists to
+     * answer for an interface-typed method value.
+     */
+    readonly bodyReceiverRepresentation: Representation | null;
+}
+export declare const publishBoxableClasses: (classes: ReadonlyMap<DeclarationId, ClassLayout>, held: ReadonlySet<DeclarationId> | null) => void;
+/** Whether a box may hold an instance of `declaration`; `true` for a compile that published nothing (no census to consult). */
+export declare const classBoxable: (classes: ReadonlyMap<DeclarationId, ClassLayout>, declaration: DeclarationId) => boolean;
+/** Publishes one compile's whole lazy-arrow-field census. Called once, before any body renders -- mirrors `publishClassStaticFieldStorage`. */
+export declare const publishLazyArrowFieldPlans: (classes: ReadonlyMap<DeclarationId, ClassLayout>, plans: ReadonlyMap<DeclarationId, ReadonlyMap<string, LazyArrowFieldPlan>>) => void;
+/** The lazy-materialization plan for one class field, or `null` when the field keeps today's eager construction. */
+export declare const lazyArrowFieldPlanOf: (classes: ReadonlyMap<DeclarationId, ClassLayout>, declaration: DeclarationId, key: string) => LazyArrowFieldPlan | null;
+/**
+ * Every qualifying field of one class, by key -- what `records.ts`'s dynamic
+ * read arm needs (which of THIS struct's fields to materialize before boxing),
+ * as opposed to `lazyArrowFieldPlanOf`'s one-field question the constructor
+ * and the static read site each ask.
+ */
+export declare const lazyArrowFieldPlansForClass: (classes: ReadonlyMap<DeclarationId, ClassLayout>, declaration: DeclarationId) => ReadonlyMap<string, LazyArrowFieldPlan> | undefined;
+/**
+ * The materialize-on-read guard for one lazy arrow field's storage, shared by
+ * every reader that observes a qualifying field's CURRENT value rather than
+ * only its presence or attributes -- `emit-properties.ts`'s ordinary property
+ * `get` (the one choke point every consumer of a field's value, a call's own
+ * callee included, already goes through) and `object-protocol.ts`'s
+ * `getOwnValue` (the "PRIMITIVE 2" read `Object.values`/`entries`/`assign`/
+ * spread/`getOwnPropertyDescriptor` all build on, per that file's own header
+ * comment) both read the SAME storage through two different doors. One
+ * authority, not two matching implementations that could drift.
+ *
+ * The receiver is bound once, not repeated: an SSA operand -- or a "known"
+ * object view's own receiver text -- may render as a deferred conversion
+ * expression, and this reads it twice over (the guard and the materializing
+ * store) if it did not bind a local first.
+ */
+export declare const lazyMaterializedFieldText: (receiverText: string, accessor: string, key: string, plan: LazyArrowFieldPlan) => string;
+/**
+ * Whether a `get` renders through the lazy-arrow-field materializing text --
+ * the ONE authority both `emit-properties.ts`'s `emitGet` and the
+ * callee-snapshot census below ask, so a field the census calls "lazily
+ * materialized" is exactly the field `emitGet` would render as one.
+ *
+ * `null` for a receiver that is not statically a class instance, a key this
+ * compile never gave a static text, or a key naming anything but a
+ * lazily-materialized field -- the same three escapes `emitGet`'s own inline
+ * check had before it was factored out to here.
+ */
+export declare const lazyArrowFieldGetPlanOf: (ctx: Pick<EmitContext, "classes" | "staticKeyTexts">, operation: GetOperation) => {
+    readonly fieldName: string;
+    readonly plan: LazyArrowFieldPlan;
+} | null;
+/**
+ * Lazy-arrow-field GET results with exactly one reader in this body, that
+ * reader being the very CALL that reads the result as its OWN callee -- the
+ * shape `emit-callable.ts`'s `emitLazyArrowFieldCall` fuses into a direct call
+ * on the census arrow, with no materialized `CallableObject` built at all.
+ *
+ * A GET outside this set keeps `lazyMaterializedFieldText`'s ordinary
+ * materialize-on-read rendering: a value that is read, passed on, or read by
+ * more than one operation has no single call fusion to feed, so its
+ * `CallableObject` has to actually exist for whatever else reads it.
+ *
+ * The three checks mirrored here from `emitLazyArrowFieldCall`'s own early,
+ * purely structural bail-outs (a non-function callee kind; a `function`-kind
+ * read naming a DIFFERENT function than the census arrow; no published ABI for
+ * the arrow's body) are proven once, here, so a GET this set admits is
+ * guaranteed to reach that fusion's `try` block. The one refusal left
+ * uncensused on purpose is the try block's own CONVERSION refusal -- a generic
+ * field's per-call-site result, the one shape a structural check here cannot
+ * predict -- which the fusion answers itself by materializing the snapshot
+ * rather than declining outright. A GET this census admits must therefore
+ * NEVER be read by `emitGet` as anything but the raw, unmaterialized snapshot:
+ * the fusion is the only consumer, and it never re-reads the field once it has
+ * the snapshot in hand.
+ */
+export declare const lazyCalleeReadsOf: (ctx: EmitContext, body: IrBody) => ReadonlySet<IrValueId>;
+/**
+ * Which class fields qualify for lazy materialization, computed once for the
+ * whole translation unit.
+ *
+ * A field's initializer thunk (`ClassField.initializer`) is not itself
+ * allocated as a value -- nothing ever wraps THE THUNK in a `CallableObject`,
+ * it is simply called once per construction -- so its own capture admission is
+ * always `{kind: 'none'}` and asking `captures` about it answers nothing.
+ * What must qualify is the closure the thunk's body ALLOCATES: for an arrow
+ * field, that thunk's IR is exactly one `allocate-callable` (naming the
+ * arrow's own FunctionId) followed by an implicit return of that value (the
+ * `[[Initializer]]` "return the evaluation of the initializer expression"
+ * shape, `census.ts`'s `isFieldInitializerBody`) -- so this walks each
+ * qualifying thunk's body once to find that operation and asks `captures` of
+ * ITS `functionId`, the same "walk to the allocate-callable" step
+ * `buildDirectCallableIndex` already performs for module-level cells.
+ *
+ * A field qualifies when that admission is `{kind: 'none'}` (the closure
+ * captures nothing, not even `this`) or `{kind: 'ok'}` with an empty slot list
+ * (captures only the receiver) -- "nothing else", per the design. A refused
+ * admission, or one with any other captured declaration, keeps the field
+ * eager: fail closed.
+ *
+ * A class the whole-program reflection census marks `'full'`
+ * (`ir/reflection-demand.ts`) may still read a field's VALUE dynamically,
+ * through `records.ts`'s `gea_readOwnField`. That used to disqualify the
+ * whole class here, fail closed, because the dispatch method is `const` and
+ * has no `Ref` back to its own instance to call the initializer with. It
+ * turns out one already exists: `records.ts`'s own accessor dispatch recovers
+ * exactly that handle from `this` (`gea::Ref<T>::adopt(const_cast<T*>(this),
+ * true)`, `renderFieldDispatcher`'s `selfText`) to call a getter/setter body
+ * from the identical `const` method. `records.ts`'s dynamic read arm for a
+ * qualifying field now does the same before boxing, so this census no longer
+ * needs to ask reflection at all -- correctness for the dynamic path is that
+ * function's job now, not a reason to keep a field eager here.
+ */
+export declare const censusLazyArrowFields: (bodies: readonly IrBody[], classes: ReadonlyMap<DeclarationId, ClassLayout>, captures: CaptureIndex) => ReadonlyMap<DeclarationId, ReadonlyMap<string, LazyArrowFieldPlan>>;
+/**
+ * The C++ struct a receiver's carrier IS, or `null` for one that is not a
+ * struct at all.
+ *
+ * Reactive storage is a property of the STRUCT, not of the declaration that
+ * happens to name it: a store class and the element record of one of its
+ * arrays are both reactive structs, and only the first has a `DeclarationId`.
+ * Asking this one question in one place is what lets the read site, the
+ * dependency census and the JSX binding all name the same member.
+ */
+export declare const structNameOfReceiver: (representation: Representation) => string | null;
+/**
+ * The struct that DECLARES field `key` on a receiver of this carrier.
+ *
+ * Not the same question as "what struct IS this receiver", and the difference
+ * is load-bearing for every reactive question: `celled` and `revisions` are
+ * keyed by the DECLARING struct (`records.ts` builds them per struct from that
+ * struct's OWN fields), because an inherited field's storage lives on the base
+ * that declares it. `structNameOfReceiver` alone names the receiver's own
+ * class, so asking it for an inherited field silently finds nothing -- which
+ * reads as "not reactive" rather than as an error.
+ *
+ * `null` for a class-ref key naming no FIELD: an accessor and a method share
+ * no reactive table, so there is nothing for a caller to look up.
+ */
+export declare const fieldDeclaringStructOf: (classes: ReadonlyMap<DeclarationId, ClassLayout>, representation: Representation, key: string) => string | null;
+/**
+ * Whether this receiver names `super` -- the one member access the language
+ * binds statically (13.3.7), so dispatching it through the object would
+ * re-enter the override that wrote it.
+ *
+ * `ir/lower.ts` mints the `receiver` operation at the BASE's class for a
+ * `super` access, so a receiver-defined value carrying any class other than
+ * this frame's own receiver's class is a super access and nothing else.
+ *
+ * One authority for what was four independent spellings of the same
+ * predicate: the virtual-setter dispatch in `emit-properties.ts`,
+ * `directClassMethodBody`, `classMemberText`'s own `isSuperAccess`, and
+ * `virtualCalleeClaim`'s exclusion of `super.m()` from virtual dispatch.
+ * Three of the four relied on an enclosing guard having already established
+ * the receiver's kind; this one is total, so a fifth caller cannot get it
+ * subtly wrong by being reached from somewhere the others never were.
+ */
+export declare const dispatchesStatically: (ctx: EmitContext, receiver: IrOperand) => boolean;
+/**
+ * Every method key a class family reaches, own or inherited, deduplicated
+ * along the inheritance chain: `method` is the body when the key binds without
+ * dispatch, and `null` when a subclass overrides the key, so the answer is a
+ * virtual call this walk has no body to name.
+ *
+ * The overridden keys are YIELDED rather than skipped because "which keys does
+ * this family reach" and "which of them bind to a body" are one walk, and a
+ * consumer that must know a key was reached-but-excluded would otherwise have
+ * to repeat it. That consumer is real: a computed read over an OPEN key domain
+ * builds one arm per bound key and cannot tell an unreachable key from one it
+ * dropped here -- and answering the second as though it were the first
+ * compiled a correct `dog[k]()` into a guaranteed abort.
+ *
+ * `classMethodValueReceiverClaim` and `computedClassPrototypeMethodText` ask
+ * two different questions of this one family -- "does ANY member convert to
+ * this callable type" and "which members DO" -- over an identical walk that
+ * each spelled out for itself.
+ */
+export declare function reachableClassMethodsOf(classes: ReadonlyMap<DeclarationId, ClassLayout>, declaration: DeclarationId): Generator<{
+    readonly key: string;
+    readonly method: (ClassMethod & {
+        readonly callable: FunctionId;
+    }) | null;
+}>;
+/**
+ * Real C++ storage for one "constructor expando" static field: `ClassName.
+ * FIELD = value;` written at module scope, after the class declaration --
+ * the idiom three.js's own JS source spells throughout (`Object3D.
+ * DEFAULT_UP = new Vector3(0, 1, 0);` right after `class Object3D {...}`,
+ * never a `static` member inside the body). No `class-lifecycle` event and no
+ * entry in `ClassLayout.staticFields` ever names one of these: the assignment
+ * IS the only declaration a JS-checked program has, so `classStaticMemberOf`
+ * genuinely has nothing to walk to for it. `name` is this compilation's own
+ * mangled global for the storage; `representation` is the carrier every
+ * observed write to it agreed on (see `censusClassStaticFields`,
+ * `translation-unit.ts`).
+ */
+export interface ClassStaticFieldStorage {
+    readonly name: string;
+    readonly representation: Representation;
+}
+/** Publishes one compile's whole static-field census. Called once, before any body renders. */
+export declare const publishClassStaticFieldStorage: (classes: ReadonlyMap<DeclarationId, ClassLayout>, storage: ReadonlyMap<DeclarationId, ReadonlyMap<string, ClassStaticFieldStorage>>) => void;
+/** The storage a `constructor-family` receiver's static key resolves to, or `null` when nothing published one for it. */
+export declare const classStaticFieldStorageOf: (classes: ReadonlyMap<DeclarationId, ClassLayout>, declaration: DeclarationId, key: string) => ClassStaticFieldStorage | null;
+/** Every key the census gave one class storage for -- the finite set a computed read of the constructor dispatches over. */
+export declare const classStaticFieldStorageKeysOf: (classes: ReadonlyMap<DeclarationId, ClassLayout>, declaration: DeclarationId) => readonly string[];
+/**
+ * The C++ storage table, which is `ir/class-static-fields.ts`'s census with
+ * this compilation's mangled global attached to each slot.
+ *
+ * The walk itself moved to `ir/` when the reflection census turned out to need
+ * the same answer: its own comment already warned that re-deriving where a
+ * `ClassName.KEY` write lands would risk "a second opinion that could disagree
+ * with the one the plan actually selected", and a second consumer asking the
+ * question a second way is that risk arriving. What is left here is the only
+ * part that was ever a C++ concern -- the NAME the printer renders.
+ */
+export declare const censusClassStaticFieldStorage: (bodies: readonly IrBody[], classes: ReadonlyMap<DeclarationId, ClassLayout>) => {
+    readonly storage: ReadonlyMap<DeclarationId, ReadonlyMap<string, ClassStaticFieldStorage>>;
+    readonly conflicts: readonly string[];
+};