@geastack/compiler 1.0.15

package/dist/ir/emission-representations.js

@@ -0,0 +1,350 @@
+import { allOperationsOf } from './model.js';
+import { operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+import { recursiveCarrierOf, representationKey, walkRepresentation } from '../representation/model.js';
+const abiCarriersOf = (abi) => [
+    ...abi.parameters.map((parameter) => parameter.value),
+    abi.result,
+    ...(abi.receiver ? [abi.receiver] : [])
+];
+const operationOwnerOf = (body, operation) => `${String(body.owner)}:${operation.kind}`;
+const classBodyOwnersOf = (layout) => [
+    layout.constructor,
+    ...layout.fields.map((field) => field.initializer),
+    ...layout.methods.map((method) => method.callable),
+    ...layout.accessors.flatMap((accessor) => [accessor.getter, accessor.setter]),
+    ...layout.staticFields.map((field) => field.initializer),
+    ...layout.staticMethods.map((method) => method.callable),
+    ...layout.staticAccessors.flatMap((accessor) => [accessor.getter, accessor.setter])
+];
+/** Recursive definition/reference carriers intentionally share representationKey. */
+const closureKeyOf = (representation) => {
+    const recursive = recursiveCarrierOf(representation);
+    return recursive ? `${representationKey(representation)}#${recursive.role}` : representationKey(representation);
+};
+/**
+ * Publish the carrier closure consumed by emission.
+ *
+ * The input is deliberately the final IR/projection set. This function never
+ * scans the sealed plan as a convenience: doing so would retain carriers for
+ * dropped bodies and recreate the phantom-struct defect this census exists to
+ * remove. `fallbackRoots` is the explicit fail-closed escape for an incomplete
+ * shake, where a subset cannot safely stand in for the program.
+ */
+export const publishEmissionRepresentationsOf = (input) => {
+    const entries = new Map();
+    const rootEntries = new Map();
+    const queue = [];
+    const queued = new Set();
+    let queueCursor = 0;
+    const expanded = new Set();
+    const retainedClassReasons = new Map();
+    const queuedClasses = new Set();
+    const retainedPlacementDeclarations = new Set();
+    const citedConversionIds = new Set();
+    const missingConversions = new Set();
+    const missingDefinitions = new Set();
+    const reasonKeyOf = (reason) => `${reason.kind}|${reason.owner}|${reason.detail}`;
+    const addReason = (table, representation, reason) => {
+        const key = closureKeyOf(representation);
+        const existing = table.get(key);
+        if (!existing) {
+            table.set(key, { representation, reasons: new Map([[reasonKeyOf(reason), reason]]) });
+            return;
+        }
+        existing.reasons.set(reasonKeyOf(reason), reason);
+    };
+    const enqueue = (representation, reason, root = false) => {
+        addReason(root ? rootEntries : entries, representation, reason);
+        const key = closureKeyOf(representation);
+        if (expanded.has(key) || queued.has(key))
+            return;
+        queued.add(key);
+        queue.push({ representation, reason, root });
+    };
+    const citeConversion = (id, owner) => {
+        if (citedConversionIds.has(id))
+            return;
+        citedConversionIds.add(id);
+        const node = input.conversions.nodeById(id);
+        if (!node) {
+            missingConversions.add(id);
+            return;
+        }
+        enqueue(node.source, { kind: 'conversion-source', owner, detail: id });
+        enqueue(node.target, { kind: 'conversion-target', owner, detail: id });
+    };
+    const citeOperand = (body, operation, operand, kind) => {
+        enqueue(operand.representation, { kind, owner: operationOwnerOf(body, operation), detail: String(operand.value) }, true);
+    };
+    // First collect the direct IR roots. Values and operation operands overlap
+    // intentionally: their separate reasons tell target consumers whether a
+    // carrier is needed by an emitted slot or by an operation's ABI.
+    for (const body of input.bodies.values()) {
+        for (const [value, representation] of body.values) {
+            enqueue(representation, { kind: 'body-value', owner: String(body.owner), detail: String(value) }, true);
+        }
+        if (body.abi)
+            for (const representation of abiCarriersOf(body.abi))
+                enqueue(representation, { kind: 'body-abi', owner: String(body.owner), detail: 'call ABI' }, true);
+        if (body.construct)
+            for (const representation of abiCarriersOf(body.construct))
+                enqueue(representation, { kind: 'body-abi', owner: String(body.owner), detail: 'construct ABI' }, true);
+        if (body.facts?.capturedReceiver)
+            enqueue(body.facts.capturedReceiver, { kind: 'capture-receiver', owner: String(body.owner), detail: 'captured receiver' }, true);
+        for (const declaration of [
+            ...(body.facts?.capturedDeclarations ?? []),
+            ...(body.facts ? [...body.facts.boxed] : []),
+            ...(body.facts ? [...body.facts.requiresEarlyBox] : [])
+        ]) {
+            retainedPlacementDeclarations.add(declaration);
+            const placement = input.placements.get(declaration);
+            if (placement?.representation && !input.omitGlobals?.has(declaration))
+                enqueue(placement.representation, { kind: 'capture-cell', owner: String(body.owner), detail: String(declaration) }, true);
+        }
+        for (const blockId of body.blockOrder) {
+            const block = body.blocks.get(blockId);
+            if (!block)
+                continue;
+            for (const operation of allOperationsOf(block)) {
+                for (const operand of operandsOfIrOperation(operation))
+                    citeOperand(body, operation, operand, 'operation-operand');
+                const result = resultOfIrOperation(operation);
+                if (result)
+                    citeOperand(body, operation, { value: result.id, representation: result.representation }, 'operation-result');
+                if (operation.kind === 'convert')
+                    citeConversion(operation.conversionUse, operationOwnerOf(body, operation));
+                if (operation.kind === 'get' && operation.nativeFieldOwnerRead) {
+                    const recipe = operation.nativeFieldOwnerRead;
+                    citeConversion(recipe.missing, operationOwnerOf(body, operation));
+                    for (const arm of recipe.arms)
+                        citeConversion(arm.conversion, operationOwnerOf(body, operation));
+                    for (const member of recipe.members)
+                        enqueue(member, { kind: 'operation-operand', owner: operationOwnerOf(body, operation), detail: 'native field-owner class identity' }, true);
+                }
+                if (operation.kind === 'merge-live-arm-rebuild' && operation.nativeTransport) {
+                    for (const arm of operation.nativeTransport.arms)
+                        citeConversion(arm.conversion, operationOwnerOf(body, operation));
+                    if (operation.nativeTransport.absence)
+                        citeConversion(operation.nativeTransport.absence, operationOwnerOf(body, operation));
+                }
+                if (operation.kind === 'call' && operation.fixedDataDefinition)
+                    citeConversion(operation.fixedDataDefinition.conversion, operationOwnerOf(body, operation));
+                if (operation.kind === 'call')
+                    for (const value of operation.objectValueConversions ?? [])
+                        citeConversion(value.conversion, operationOwnerOf(body, operation));
+                if (operation.kind === 'get' && operation.typedComputedRead) {
+                    for (const arm of operation.typedComputedRead.arms)
+                        citeConversion(arm.conversion, operationOwnerOf(body, operation));
+                    if (operation.typedComputedRead.receiverBounded)
+                        citeConversion(operation.typedComputedRead.receiverBounded.missing, operationOwnerOf(body, operation));
+                }
+                if (operation.kind === 'binding-read' || operation.kind === 'binding-write')
+                    retainedPlacementDeclarations.add(operation.declaration);
+            }
+        }
+    }
+    // The target emits every non-local placement (region/global and host
+    // boundaries) from its placement tables. Local cells are emitted only when
+    // the final IR or capture facts name them; otherwise there is no frame slot
+    // to materialize. `omitGlobals` applies only to the local liveness set here:
+    // global storage, externs, and absent definitions remain target declarations.
+    const retainedPlacements = new Map();
+    for (const [declaration, placement] of input.placements) {
+        if (input.omitGlobals?.has(declaration) && (placement.storage.kind === 'local' || placement.storage.kind === 'region'))
+            continue;
+        if (placement.storage.kind === 'local' && !retainedPlacementDeclarations.has(declaration))
+            continue;
+        retainedPlacements.set(declaration, placement);
+        if (placement.representation)
+            enqueue(placement.representation, { kind: 'retained-placement', owner: String(declaration), detail: placement.storage.kind }, true);
+    }
+    // Every class in the final shaken class map is rendered by the target. Seed
+    // them all; class-ref discovery below still feeds the same queue so nominal
+    // layouts reached through nested carriers cannot be missed.
+    const bodyOwners = new Set([...input.bodies.values()].map((body) => String(body.sourceOwner)));
+    for (const [declaration, layout] of input.classes) {
+        const memberBodyRetained = classBodyOwnersOf(layout).some((owner) => owner !== null && bodyOwners.has(String(owner)));
+        retainedClassReasons.set(declaration, {
+            kind: 'retained-class',
+            owner: String(declaration),
+            detail: memberBodyRetained ? 'retained member body' : 'final class layout'
+        });
+    }
+    const classQueue = [];
+    const markClass = (declaration, detail) => {
+        if (retainedClassReasons.has(declaration)) {
+            if (!queuedClasses.has(declaration) && !expandedClasses.has(declaration)) {
+                queuedClasses.add(declaration);
+                classQueue.push(declaration);
+            }
+            return;
+        }
+        retainedClassReasons.set(declaration, { kind: 'retained-class', owner: String(declaration), detail });
+        queuedClasses.add(declaration);
+        classQueue.push(declaration);
+    };
+    const expandedClasses = new Set();
+    for (const declaration of retainedClassReasons.keys())
+        markClass(declaration, 'final class layout');
+    const expandClassQueue = () => {
+        while (classQueue.length > 0) {
+            const declaration = classQueue.pop();
+            if (!declaration || expandedClasses.has(declaration))
+                continue;
+            expandedClasses.add(declaration);
+            const layout = input.classes.get(declaration);
+            if (!layout)
+                continue;
+            if (layout.instance)
+                enqueue(layout.instance, { kind: 'class-instance', owner: String(declaration), detail: 'class instance carrier' }, true);
+            if (layout.construct)
+                for (const representation of abiCarriersOf(layout.construct))
+                    enqueue(representation, { kind: 'class-construct', owner: String(declaration), detail: 'class construct ABI' }, true);
+            for (const field of layout.nativeStorage?.fields.map((field) => ({ key: field.key, representation: field.value })) ?? layout.fields)
+                if (field.representation)
+                    enqueue(field.representation, { kind: 'class-field', owner: String(declaration), detail: field.key }, true);
+            for (const field of layout.staticFields)
+                if (field.representation)
+                    enqueue(field.representation, { kind: 'class-static-field', owner: String(declaration), detail: field.key }, true);
+            if (layout.nativeBase)
+                enqueue(layout.nativeBase.instance, { kind: 'class-instance', owner: String(declaration), detail: 'native base instance carrier' }, true);
+            if (layout.base)
+                markClass(layout.base, `base of ${String(declaration)}`);
+        }
+    };
+    expandClassQueue();
+    // Complete the representation closure. walkRepresentation covers all
+    // ordinary nested carriers; nominal layout expansion above is the only
+    // compiler-context-dependent extension.
+    const ordered = new Map();
+    const drainRepresentations = () => {
+        while (queueCursor < queue.length) {
+            const item = queue[queueCursor++];
+            if (!item)
+                continue;
+            const key = closureKeyOf(item.representation);
+            const entry = entries.get(key) ?? rootEntries.get(key);
+            if (entry && !entries.has(key))
+                entries.set(key, entry);
+            if (!ordered.has(key))
+                ordered.set(key, item.representation);
+            if (expanded.has(key))
+                continue;
+            expanded.add(key);
+            for (const child of walkRepresentation(item.representation)) {
+                if (child === item.representation)
+                    continue;
+                if (child.kind === 'class-ref')
+                    markClass(child.declaration, `carrier ${representationKey(child)}`);
+                const childReason = {
+                    kind: item.root ? item.reason.kind : 'operation-result',
+                    owner: item.reason.owner,
+                    detail: `nested in ${key}`
+                };
+                enqueue(child, childReason);
+            }
+            if (item.representation.kind === 'class-ref') {
+                markClass(item.representation.declaration, `carrier ${representationKey(item.representation)}`);
+                const runtimeLayout = input.classes.get(item.representation.declaration);
+                const base = runtimeLayout ? runtimeLayout.base : (item.representation.ancestors[0] ?? null);
+                if (base !== null && !runtimeLayout?.nativeBase) {
+                    const instance = input.classes.get(base)?.instance ?? input.resolveClassRef?.(base);
+                    if (instance?.kind === 'class-ref')
+                        enqueue(instance, { kind: 'class-instance', owner: String(base), detail: 'retained physical base' });
+                }
+            }
+            if (item.representation.kind === 'native-record-ref' && item.representation.recursive?.role === 'reference') {
+                const layout = input.deriver.layoutOf(item.representation.recursive.type);
+                const recursive = recursiveCarrierOf(layout);
+                const isDefinition = recursive?.type === item.representation.recursive.type &&
+                    recursive.role === 'definition' &&
+                    (layout.kind === 'array-object' ||
+                        layout.kind === 'keyed-collection' ||
+                        layout.kind === 'dictionary' ||
+                        layout.kind === 'function-value-dispatch');
+                if (isDefinition) {
+                    const reason = {
+                        kind: 'native-layout',
+                        owner: item.reason.owner,
+                        detail: `recursive definition ${item.representation.recursive.type}`
+                    };
+                    enqueue(layout, reason);
+                }
+                else {
+                    missingDefinitions.add(String(item.representation.recursive.type));
+                }
+            }
+            else if ((item.representation.kind === 'native-record-ref' || item.representation.kind === 'class-ref') &&
+                (item.representation.kind !== 'native-record-ref' ||
+                    (item.representation.native === null && item.representation.recursive === undefined))) {
+                const rawLayout = input.deriver.layoutOf(item.representation.shapeId);
+                const nativeStorage = item.representation.kind === 'class-ref' ? input.classes.get(item.representation.declaration)?.nativeStorage : undefined;
+                const layout = nativeStorage !== undefined && (rawLayout.kind === 'record' || rawLayout.kind === 'record-with-index')
+                    ? { ...rawLayout, fields: nativeStorage.fields }
+                    : rawLayout;
+                const reason = {
+                    kind: 'native-layout',
+                    owner: item.reason.owner,
+                    detail: item.representation.shapeId
+                };
+                for (const child of walkRepresentation(layout)) {
+                    if (child === layout)
+                        continue;
+                    enqueue(child, reason);
+                }
+            }
+        }
+    };
+    drainRepresentations();
+    while (classQueue.length > 0) {
+        expandClassQueue();
+        drainRepresentations();
+    }
+    // Incomplete shake or an IR that cites a conversion the authority cannot
+    // resolve cannot safely drive a reduced target closure. Reintroduce the
+    // caller-supplied plan roots and report the incomplete status; never guess.
+    const complete = input.complete && missingConversions.size === 0 && missingDefinitions.size === 0;
+    if (!complete) {
+        for (const representation of input.fallbackRoots ?? [])
+            enqueue(representation, { kind: 'fallback-plan-root', owner: 'sealed-plan', detail: 'incomplete emission census' }, true);
+        drainRepresentations();
+        while (classQueue.length > 0) {
+            expandClassQueue();
+            drainRepresentations();
+        }
+    }
+    const closure = new Map();
+    const publishedEntryOf = (entry) => ({
+        representation: entry.representation,
+        reasons: Object.freeze([...entry.reasons.values()])
+    });
+    for (const [key, representation] of ordered) {
+        const nested = entries.get(key);
+        const direct = rootEntries.get(key);
+        if (!nested && !direct) {
+            closure.set(key, { representation, reasons: [] });
+            continue;
+        }
+        const unique = new Map();
+        for (const reason of [...(nested?.reasons.values() ?? []), ...(direct?.reasons.values() ?? [])])
+            unique.set(reasonKeyOf(reason), reason);
+        closure.set(key, { representation: nested?.representation ?? direct.representation, reasons: Object.freeze([...unique.values()]) });
+    }
+    const reasons = new Map();
+    for (const [key, entry] of closure)
+        reasons.set(key, entry.reasons);
+    return Object.freeze({
+        representations: Object.freeze([...ordered.values()]),
+        complete,
+        roots: Object.freeze([...rootEntries.values()].map(publishedEntryOf)),
+        closure,
+        reasons,
+        retainedClasses: new Set(retainedClassReasons.keys()),
+        retainedPlacements,
+        conversions: new Map([...citedConversionIds]
+            .map((id) => [id, input.conversions.nodeById(id)])
+            .filter((row) => row[1] !== null)),
+        missingConversions: Object.freeze([...missingConversions]),
+        missingDefinitions: Object.freeze([...missingDefinitions])
+    });
+};

package/dist/ir/facts.d.ts

@@ -0,0 +1,218 @@
+import type { DeclarationId, FunctionId, IrValueId } from '../identity/ids.js';
+import { type DeadValueRules } from './dead-values.js';
+import type { ForwardedBinding, ForwardingPolicy } from './deferral.js';
+import { type HoistPlan } from './hoist.js';
+import { type IntegerStorageFacts } from './integers.js';
+import { type CallOperation, type ComputeOperation, type GetOperation, type IrBody, type IrOperand } from './model.js';
+import { type NumericIntrinsic } from './numeric-intrinsics.js';
+import { type SharedStringLayout } from './string-layout-reuse.js';
+import { type TypeQueryComparison } from './type-query-results.js';
+/**
+ * Every per-body census the printer needs before it renders a line, computed
+ * in one place, in the one order they depend on each other in.
+ *
+ * Distinct from `IrBody.facts` (`ir/captures.ts`), which is the whole-program
+ * capture answer sealed onto the body before rendering starts. These are the
+ * per-body questions, asked once per body at render entry; the two converge
+ * when the remaining Phase 3 rows land.
+ *
+ * These thirteen analyses used to run inline in `targets/cpp/emit.ts`, each
+ * copying its answer into the emit context. Nothing about them is C++: they ask
+ * what a body does -- which results nothing reads, which reads may be deferred
+ * to their single use, which numbers fit a `long long`, which loop-invariant
+ * reads may be hoisted -- and the printer only spells the answers. What made
+ * them live in the target was the ORDER, which is real and subtle and was
+ * recorded only as comments between the calls: the type-query census removes
+ * values from the deferral census, the hoists remove more, and the string
+ * length reuse removes more still, so reading the deferral set at the wrong
+ * point in the sequence silently answers a question with a set that is about
+ * to shrink. Here that order is the body of one function, stated once, and a
+ * reader who needs to know why a step sits where it does finds the reason at
+ * the step rather than in a comment beside a call site.
+ *
+ * The target still owns two decisions inside the sequence, because both are
+ * about C++ storage rather than about the program, and both are needed
+ * mid-order. They arrive as `IrBodyCensusPolicy` hooks, invoked exactly where
+ * the inline pipeline invoked them.
+ */
+export interface IrBodyCensus {
+    /** Protocol cursors that never escape their `get-iterator`, so the printer may hold them by value. */
+    readonly localIterators: ReadonlySet<IrValueId>;
+    /** Values with exactly one reader, renderable at that reader -- already shrunk by every later census that claims one. */
+    readonly deferrable: ReadonlySet<IrValueId>;
+    readonly callArgumentOnly: ReadonlySet<IrValueId>;
+    /** Cells whose one write renders nothing and whose one read spells the written value -- see `deferral.ts`'s `ForwardedBinding`. Shrunk with `deferrable`: a forwarding whose value or read stopped deferring is withdrawn. */
+    readonly forwardedBindings: ReadonlyMap<DeclarationId, ForwardedBinding>;
+    /** Results nothing reads and whose producer has no other effect. Disjoint from `deferrable` by construction. */
+    readonly dead: ReadonlySet<IrValueId>;
+    /** Results nothing reads, whatever their producer does. */
+    readonly unread: ReadonlySet<IrValueId>;
+    readonly booleanConstants: ReadonlyMap<IrValueId, boolean>;
+    readonly typeQueryValues: ReadonlySet<IrValueId>;
+    readonly typeQueryBindings: ReadonlySet<DeclarationId>;
+    readonly typeQueryComparisons: ReadonlyMap<ComputeOperation, TypeQueryComparison>;
+    readonly integerValues: ReadonlySet<IrValueId>;
+    readonly integerBindings: ReadonlySet<DeclarationId>;
+    readonly remainderForms: ReadonlyMap<IrValueId, 'restated' | 'dynamic'>;
+    readonly numericCalls: ReadonlyMap<CallOperation, NumericIntrinsic>;
+    readonly numericCallOnly: ReadonlySet<IrValueId>;
+    readonly loopInvariantValues: ReadonlySet<IrValueId>;
+    readonly hoists: HoistPlan;
+    readonly hoistedResults: ReadonlySet<IrValueId>;
+    readonly sharedStringLayouts: ReadonlyMap<IrValueId, SharedStringLayout>;
+    readonly reusedStringLengths: ReadonlyMap<IrValueId, IrOperand>;
+}
+/**
+ * What the target answers for its own carriers, plus the two points in the
+ * order where it must act.
+ *
+ * Every field here is a question the IR genuinely cannot answer for itself: it
+ * is about how this backend spells or stores a thing, and a second answer
+ * derived from the IR would be a second authority over the printer's own
+ * storage decisions.
+ */
+export interface IrBodyCensusPolicy {
+    /** Whether this member read is a plain load the printer can move to its single use (not, for instance, a reactive cell whose spelling differs inline). */
+    readonly deferrableMemberRead: (operation: GetOperation) => boolean;
+    /** Which renderings spell a forwarded call once, and which cells are private enough to forward -- see `deferral.ts`'s `ForwardingPolicy`. */
+    readonly forwarding: ForwardingPolicy;
+    /** What counts as a pure or by-name-reached producer, so a result nothing reads may be deleted with it. */
+    readonly deadValues: DeadValueRules;
+    /** Whether this cell is a private local `string` whose `typeof` result may be saved rather than recomputed. */
+    readonly stringQueryCell: (declaration: DeclarationId) => boolean;
+    /** What a whole-program census already settled about this body's integer storage. */
+    readonly integerStorage: IntegerStorageFacts;
+    /**
+     * The target's constant spelling, which runs after the dead/unread censuses
+     * and before the type-query census.
+     *
+     * Position is the whole contract: the spellings are read by the predicates
+     * this sequence calls later, and the dead set is what decides which of them
+     * are worth minting at all.
+     */
+    readonly spellConstants: () => void;
+    /**
+     * The target's formal-cell and capacity decisions, which run after the
+     * integer census -- the one thing that can make a cell and its own formal
+     * two different storages -- and before the hoists, whose relocations this
+     * step is allowed to name. Returns the values that ended up carried by a
+     * formal cell, which is what the string-length reuse census treats as stable.
+     *
+     * It is handed the facts settled so far, because the deferral set it reads
+     * is still the one the hoists have not yet claimed from: a bound this step
+     * declines to name because a deferred value already withholds it must go on
+     * declining after that value is relocated, and a step reading the final set
+     * would name it a second time.
+     */
+    readonly formalStorage: (settled: IrBodyCensusBeforeHoists) => ReadonlySet<DeclarationId>;
+}
+/** What is known when `formalStorage` runs: everything except the hoists and the two censuses that read them. */
+export type IrBodyCensusBeforeHoists = Pick<IrBodyCensus, 'localIterators' | 'deferrable' | 'callArgumentOnly' | 'forwardedBindings' | 'dead' | 'unread' | 'booleanConstants' | 'typeQueryValues' | 'typeQueryBindings' | 'typeQueryComparisons' | 'integerValues' | 'integerBindings' | 'remainderForms' | 'numericCalls' | 'numericCallOnly'>;
+export declare const irBodyCensusOf: (body: IrBody, policy: IrBodyCensusPolicy) => IrBodyCensus;
+/**
+ * Where every value in this body came from -- purely syntactic indices over
+ * the IR, with no C++ in the answer at all.
+ *
+ * The no-write-during-render rule, which moved these facts out of the target:
+ * `targets/cpp/emit.ts`'s `emitCompute`, `targets/cpp/emit-properties.ts`'s
+ * `emitGet` and `targets/cpp/emit-bindings.ts`'s `emitBindingRead` used to
+ * record `computeOrigins`/`propertyReadOrigins`/`bindingReadDeclarations` as a
+ * SIDE EFFECT of rendering the very operation each map is keyed by -- "the
+ * compute operation that defined this value" needs nothing about what has
+ * been printed, or in what order; it is answered by the operation's own
+ * `result.id`, which exists before any statement is emitted. Recording it at
+ * print time made the printer a second authority over a fact the IR already
+ * settles, and meant a value visited twice (`ir/dead-values.ts`'s dead-value
+ * short-circuit skipped `emitCompute` entirely, so `emit.ts`'s
+ * `registerDirectCalleeOfDeadValue` had its OWN, independent
+ * `bindingReadDeclarations.set` to avoid a hole) was one fact filled from two
+ * places instead of one.
+ *
+ * `valueCellReads` (`targets/cpp/deferral-safety.ts`'s former
+ * `collectValueCellReads`) is the fixed-point closure of `bindingReadDeclarations`
+ * over every operand a value derives from -- also purely a property of the
+ * operand graph, also unrelated to render order.
+ */
+export interface BodyValueOrigins {
+    /** Every `compute` operation's own definition, by the value it produced. */
+    readonly computeOrigins: ReadonlyMap<IrValueId, ComputeOperation>;
+    /** Every `get` operation's own definition, by the value it produced. */
+    readonly propertyReadOrigins: ReadonlyMap<IrValueId, GetOperation>;
+    /**
+     * Every `constant` operation's own literal text, by the value it defined.
+     *
+     * The same table the printer builds for itself in `spellConstants`, stated
+     * here because a census that has to ask "is this property key a literal, and
+     * which one" needs the answer before any spelling exists -- a static member
+     * name is a fact about the operation, not about the line it becomes.
+     *
+     * Named for what it ANSWERS rather than for how it is built, because there
+     * is a second map that would otherwise share the name and must never be
+     * confused with it: `EmitContext.constantTexts` starts EMPTY at the point
+     * this one is already complete, and then grows during the render as a
+     * `typeof` whose operand's tag is known folds to a literal. Feeding that one
+     * to a claim lets a fold decide a key the program computed. Both are
+     * `ReadonlyMap<IrValueId, string>`, so only the name stands between them --
+     * which is why `scripts/architecture.mjs` now also refuses to let
+     * `ctx.constantTexts` be passed as an argument at all.
+     */
+    readonly staticKeyTexts: ReadonlyMap<IrValueId, string>;
+    /** The declaration every `binding-read` value loaded from, live or dead. */
+    readonly bindingReadDeclarations: ReadonlyMap<IrValueId, DeclarationId>;
+    /** The operand every `convert` result was converted FROM, so a consumer can walk a value's history through a carrier change. */
+    readonly conversionSources: ReadonlyMap<IrValueId, IrOperand>;
+    /**
+     * The callee value behind every call's result -- which value it CALLED,
+     * which is the same fact whichever of the printer's dispatch paths spells
+     * the call.
+     */
+    readonly callCallees: ReadonlyMap<IrValueId, IrValueId>;
+    /**
+     * Every value whose EVERY read in this body is as a call's callee -- a host
+     * function read and called on the spot (`Math.pow(x)`), never compared,
+     * stored, passed or returned. Counted over the operands and terminators the
+     * body states, so a read that also feeds a binding write (`(f = Math.pow)(x)`)
+     * is not in it. The printer uses it to leave the hot call path alone: the
+     * identity a value read of a host builtin must carry (`emit-host-properties.ts`)
+     * is only observable where the value goes somewhere other than a call.
+     */
+    readonly calleeOnlyValues: ReadonlySet<IrValueId>;
+    /**
+     * Where each member of a record-shaped value came FROM, by member key, so a
+     * consumer can still see a member's expression after it has become struct
+     * storage.
+     *
+     * Two producers, and the accumulation between them is why this is a walk in
+     * block order rather than a map comprehension: an `allocate-record` states
+     * every member at once, while an object literal that installs its members
+     * by STORE builds the same answer one `set` at a time, each carrying the
+     * accumulated map onto the receiver and onto its own result (a store
+     * threads its receiver onward).
+     *
+     * A store counts only when its key is a `constant` -- the same test the
+     * printer made against its own constant table, restated against the IR the
+     * table is filled from.
+     *
+     * BOTH store kinds, because `emit-properties.ts`'s `emitPropertyStore`
+     * serves both and accumulated for both: an object literal whose members are
+     * installed by `define-own-property` (which is what a descriptor literal
+     * is) builds its answer exactly the way a `set`-installed one does, and
+     * covering only `set` loses the descriptor `Object.defineProperty` on a
+     * dictionary reads its typed `value` operand out of.
+     */
+    readonly recordFieldSources: ReadonlyMap<IrValueId, ReadonlyMap<string, IrOperand>>;
+    /**
+     * Every callable this body allocated as a THUNK -- a zero-parameter,
+     * receiver-less `function-value-dispatch` -- to the function whose body it
+     * runs.
+     *
+     * The carrier is unwrapped through `optional` first, because a thunk stored
+     * into an absence-capable slot is still a thunk; that is the shape the
+     * printer's own two write sites tested, one of them on the unwrapped
+     * carrier and one on the bare one.
+     */
+    readonly thunkValues: ReadonlyMap<IrValueId, FunctionId>;
+    /** Every cell a value transitively reads, over the whole body -- see `targets/cpp/deferral-safety.ts`'s `readsCell`. */
+    readonly valueCellReads: ReadonlyMap<IrValueId, ReadonlySet<DeclarationId>>;
+}
+export declare const bodyValueOriginsOf: (body: IrBody) => BodyValueOrigins;