@geastack/compiler 1.0.15

package/dist/semantics/symbol-keyed-expando-source-transform.d.ts

@@ -0,0 +1,4 @@
+export declare const symbolKeyedExpandoSourceTransform: (input: {
+    readonly fileName: string;
+    readonly text: string;
+}) => string | null;

package/dist/semantics/symbol-keyed-expando-source-transform.js

@@ -0,0 +1,66 @@
+import ts from 'typescript';
+const isJavaScriptFile = (fileName) => fileName.endsWith('.js') || fileName.endsWith('.mjs') || fileName.endsWith('.cjs');
+/** `Symbol.<name>` -- a well-known symbol read straight off the global `Symbol`. */
+const isWellKnownSymbolKey = (key) => ts.isPropertyAccessExpression(key) && ts.isIdentifier(key.expression) && key.expression.text === 'Symbol';
+/**
+ * The identifier a member chain is rooted at, walking property reads only:
+ * `o` for `o`, `o.x` and `o.x.y`; `null` for a chain that passes through a
+ * call, an element read, `this`, or anything else this transform does not
+ * claim to understand.
+ */
+const chainRootOf = (holder) => {
+    let node = holder;
+    while (ts.isPropertyAccessExpression(node))
+        node = node.expression;
+    return ts.isIdentifier(node) ? node : null;
+};
+/**
+ * Every identifier this file declares with an object-literal initialiser, by
+ * name -- collected once per file so each candidate costs one set lookup.
+ * Scoping is deliberately ignored: a same-named shadow with a non-literal
+ * initialiser would at worst parenthesise a function on a holder the checker
+ * could have bound, and a parenthesised function is still a correct program.
+ */
+const objectLiteralDeclarationsIn = (file) => {
+    const names = new Set();
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isObjectLiteralExpression(node.initializer))
+            names.add(node.name.text);
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    return names;
+};
+const candidatesIn = (file) => {
+    const holders = objectLiteralDeclarationsIn(file);
+    if (holders.size === 0)
+        return [];
+    const found = [];
+    const visit = (node) => {
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isElementAccessExpression(node.left) &&
+            isWellKnownSymbolKey(node.left.argumentExpression) &&
+            (ts.isFunctionExpression(node.right) || ts.isArrowFunction(node.right))) {
+            const root = chainRootOf(node.left.expression);
+            if (root && holders.has(root.text))
+                found.push({ start: node.right.getStart(file), end: node.right.end });
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(file, visit);
+    return found;
+};
+export const symbolKeyedExpandoSourceTransform = (input) => {
+    if (!isJavaScriptFile(input.fileName) || !input.text.includes('[Symbol.'))
+        return null;
+    const file = ts.createSourceFile(input.fileName, input.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const candidates = candidatesIn(file);
+    if (candidates.length === 0)
+        return null;
+    let rewritten = input.text;
+    for (const candidate of [...candidates].reverse()) {
+        rewritten = `${rewritten.slice(0, candidate.start)}(${rewritten.slice(candidate.start, candidate.end)})${rewritten.slice(candidate.end)}`;
+    }
+    return rewritten;
+};

package/dist/semantics/this-constructor-source-transform.d.ts

@@ -0,0 +1,4 @@
+export declare const thisConstructorSourceTransform: (input: {
+    readonly fileName: string;
+    readonly text: string;
+}) => string | null;

package/dist/semantics/this-constructor-source-transform.js

@@ -0,0 +1,122 @@
+import ts from 'typescript';
+/** `this.constructor` -- the literal receiver, never an alias or a plain object. */
+const isThisConstructorAccess = (node) => ts.isPropertyAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword && node.name.text === 'constructor';
+/**
+ * The nearest function that actually BINDS `this` for `node`, skipping
+ * arrow functions (which inherit `this` from their enclosing scope rather
+ * than rebinding it) -- `null` when `node` sits at the top level of a file
+ * with no such function at all.
+ */
+const thisBindingBoundary = (node) => {
+    let n = node.parent;
+    while (n) {
+        if (ts.isArrowFunction(n)) {
+            n = n.parent;
+            continue;
+        }
+        if (ts.isMethodDeclaration(n) ||
+            ts.isGetAccessor(n) ||
+            ts.isSetAccessor(n) ||
+            ts.isConstructorDeclaration(n) ||
+            ts.isFunctionDeclaration(n) ||
+            ts.isFunctionExpression(n))
+            return n;
+        n = n.parent;
+    }
+    return null;
+};
+/**
+ * Whether `node`'s `this` is a class instance: its nearest `this`-binding
+ * function is a method/accessor/constructor declared directly on a class,
+ * never a plain `function` (whose `this` a caller could bind to anything)
+ * and never one with no class parent at all (an object-literal method, a
+ * free function).
+ */
+const isClassInstanceThis = (node) => {
+    const boundary = thisBindingBoundary(node);
+    if (!boundary)
+        return false;
+    if (ts.isFunctionDeclaration(boundary) || ts.isFunctionExpression(boundary))
+        return false;
+    return boundary.parent !== undefined && ts.isClassLike(boundary.parent);
+};
+/**
+ * Whether `file` anywhere assigns to a `.constructor` property -- the one
+ * case that would make `this.constructor` not denote the class's own
+ * constructor at runtime. Scanned whole-file, conservatively: a single
+ * reassignment anywhere disqualifies every occurrence in the file, rather
+ * than this transform trying to prove which classes it can and cannot reach.
+ */
+const fileReassignsConstructor = (file) => {
+    let found = false;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isPropertyAccessExpression(node.left) &&
+            node.left.name.text === 'constructor') {
+            found = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    return found;
+};
+/**
+ * How to spell the cast, in a language the file is actually written in.
+ *
+ * `x as T` is TypeScript syntax. Splicing it into a `.js` file makes the
+ * checker report "Type assertion expressions can only be used in TypeScript
+ * files" for every rewritten site -- it recovers and still infers the type, so
+ * the measurement looked clean, but the transform was writing source the
+ * language does not have. JavaScript's own spelling for the same assertion is
+ * a parenthesised JSDoc type cast, which `checkJs` reads with identical
+ * meaning and no diagnostic. Every three.js file this transform touches is
+ * `.js`; a TypeScript class reaches the same rule through `as`.
+ */
+const castTo = (fileName, expression, type) => fileName.endsWith('.ts') || fileName.endsWith('.tsx') ? `(${expression} as ${type})` : `(/** @type {${type}} */ (${expression}))`;
+const candidatesIn = (file) => {
+    const found = [];
+    const visit = (node) => {
+        if (ts.isNewExpression(node) && isThisConstructorAccess(node.expression) && isClassInstanceThis(node)) {
+            found.push({
+                calleeStart: node.expression.getStart(file),
+                calleeEnd: node.expression.end,
+                replacement: castTo(file.fileName, node.expression.getText(file), 'new (...args: any[]) => this')
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(file, visit);
+    return found;
+};
+const scriptKindOf = (fileName) => {
+    if (fileName.endsWith('.tsx'))
+        return ts.ScriptKind.TSX;
+    if (fileName.endsWith('.jsx'))
+        return ts.ScriptKind.JSX;
+    if (fileName.endsWith('.js') || fileName.endsWith('.mjs') || fileName.endsWith('.cjs'))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+};
+export const thisConstructorSourceTransform = (input) => {
+    // A file that never spells `.constructor` cannot contain the idiom -- one
+    // substring test is what a file this transform has nothing to do with costs.
+    if (!input.text.includes('.constructor'))
+        return null;
+    const file = ts.createSourceFile(input.fileName, input.text, ts.ScriptTarget.Latest, true, scriptKindOf(input.fileName));
+    if (fileReassignsConstructor(file))
+        return null;
+    const candidates = candidatesIn(file);
+    if (candidates.length === 0)
+        return null;
+    let rewritten = input.text;
+    // Spliced from the end so every earlier candidate's range is still the
+    // range it was measured at -- see the module comment.
+    for (const candidate of [...candidates].reverse()) {
+        rewritten = rewritten.slice(0, candidate.calleeStart) + candidate.replacement + rewritten.slice(candidate.calleeEnd);
+    }
+    return rewritten;
+};

package/dist/semantics/uninstantiable-classes.d.ts

@@ -0,0 +1,22 @@
+import ts from 'typescript';
+import type { DeclarationId } from '../identity/ids.js';
+import type { IdentityTable } from './normalize/identities.js';
+/**
+ * The classes no evaluation can produce an instance of: the constructor's own
+ * body cannot complete normally -- it has no `return`, and one of its
+ * top-level statements throws or calls a function whose declared result is
+ * `never` -- or a class it extends is such a class, since every derived
+ * construction runs its base's.
+ *
+ * A host target states capabilities it does not have this way: node-compat's
+ * `Http2ServerRequest` extends the HTTP/1 `IncomingMessage` so the library's
+ * `IncomingMessage | Http2ServerRequest` unions resolve, and its constructor
+ * calls `nodeNotImplemented`, declared `never`. `x instanceof
+ * Http2ServerRequest` is then false for every value the program can hold,
+ * whatever carries it (`projection/instance-test.ts`).
+ *
+ * `never` is the checker's statement of a function's result, which the
+ * program's own compiled body has to honour: a body that returns normally
+ * where `never` was declared does not typecheck.
+ */
+export declare const uninstantiableClassesOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => ReadonlySet<DeclarationId>;

package/dist/semantics/uninstantiable-classes.js

@@ -0,0 +1,75 @@
+import ts from 'typescript';
+/** Whether `body` can complete normally at all: no `return` anywhere, and a top-level statement that never completes. */
+const bodyNeverCompletes = (checker, body) => {
+    let returns = false;
+    const visit = (node) => {
+        if (returns || ts.isFunctionLike(node) || ts.isClassLike(node))
+            return;
+        if (ts.isReturnStatement(node)) {
+            returns = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(body);
+    if (returns)
+        return false;
+    return body.statements.some((statement) => {
+        if (ts.isThrowStatement(statement))
+            return true;
+        if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
+            return false;
+        const signature = checker.getResolvedSignature(statement.expression);
+        return signature !== undefined && (checker.getReturnTypeOfSignature(signature).flags & ts.TypeFlags.Never) !== 0;
+    });
+};
+/**
+ * The classes no evaluation can produce an instance of: the constructor's own
+ * body cannot complete normally -- it has no `return`, and one of its
+ * top-level statements throws or calls a function whose declared result is
+ * `never` -- or a class it extends is such a class, since every derived
+ * construction runs its base's.
+ *
+ * A host target states capabilities it does not have this way: node-compat's
+ * `Http2ServerRequest` extends the HTTP/1 `IncomingMessage` so the library's
+ * `IncomingMessage | Http2ServerRequest` unions resolve, and its constructor
+ * calls `nodeNotImplemented`, declared `never`. `x instanceof
+ * Http2ServerRequest` is then false for every value the program can hold,
+ * whatever carries it (`projection/instance-test.ts`).
+ *
+ * `never` is the checker's statement of a function's result, which the
+ * program's own compiled body has to honour: a body that returns normally
+ * where `never` was declared does not typecheck.
+ */
+export const uninstantiableClassesOf = (checker, identities, files) => {
+    const answers = new Map();
+    const uninstantiable = (node) => {
+        const known = answers.get(node);
+        if (known !== undefined)
+            return known;
+        answers.set(node, false);
+        const constructor = node.members.find((member) => ts.isConstructorDeclaration(member) && !!member.body);
+        let answer = constructor?.body !== undefined && bodyNeverCompletes(checker, constructor.body);
+        const heritage = node.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0];
+        if (!answer && heritage) {
+            const symbol = checker.getSymbolAtLocation(heritage.expression);
+            const resolved = symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+            const bases = (resolved?.declarations ?? []).filter((declaration) => ts.isClassLike(declaration));
+            answer = bases.length === 1 && !bases[0].getSourceFile().isDeclarationFile && uninstantiable(bases[0]);
+        }
+        answers.set(node, answer);
+        return answer;
+    };
+    const found = new Set();
+    for (const file of files) {
+        if (file.isDeclarationFile)
+            continue;
+        const visit = (node) => {
+            if (ts.isClassLike(node) && uninstantiable(node))
+                found.add(identities.declarationIdOf(node));
+            ts.forEachChild(node, visit);
+        };
+        visit(file);
+    }
+    return found;
+};

package/dist/targets/cpp/balanced-units.d.ts

@@ -0,0 +1,3 @@
+import type { CppRenderedUnit } from './translation-unit.js';
+/** Fixed buckets keep an edit from repacking unrelated compilation units. */
+export declare const balanceCppUnits: (units: readonly CppRenderedUnit[], stem: string) => readonly CppRenderedUnit[];

package/dist/targets/cpp/balanced-units.js

@@ -0,0 +1,58 @@
+import { Buffer } from 'node:buffer';
+import { createCppDocumentBuilder, emptyCppFacts, render } from './document.js';
+const bucketOf = (name) => {
+    let hash = 2166136261;
+    for (let index = 0; index < name.length; index++)
+        hash = Math.imul(hash ^ name.charCodeAt(index), 16777619);
+    return (hash >>> 0) % 16;
+};
+/** Fixed buckets keep an edit from repacking unrelated compilation units. */
+export const balanceCppUnits = (units, stem) => {
+    const result = [];
+    const buckets = new Map();
+    for (const unit of units) {
+        if (unit.role !== 'module' || Buffer.byteLength(unit.source, 'utf8') > 16 * 1024) {
+            result.push(unit);
+            continue;
+        }
+        const bucket = bucketOf(unit.fileName);
+        const group = buckets.get(bucket) ?? [];
+        group.push(unit);
+        buckets.set(bucket, group);
+    }
+    for (const [bucket, members] of [...buckets].sort(([left], [right]) => left - right)) {
+        let group = [];
+        let bytes = 0;
+        let part = 0;
+        const publish = () => {
+            if (group.length === 0)
+                return;
+            if (group.length === 1)
+                result.push(group[0]);
+            else {
+                const builder = createCppDocumentBuilder();
+                for (const unit of group)
+                    builder.append({ text: unit.source, facts: emptyCppFacts });
+                result.push({
+                    role: 'module',
+                    fileName: `${stem}.group-${bucket.toString(16).padStart(2, '0')}-${part}.cpp`,
+                    sourceFile: null,
+                    sourceFiles: group.flatMap((unit) => (unit.sourceFile === null ? [] : [unit.sourceFile])),
+                    source: render(builder.seal())
+                });
+            }
+            part++;
+            group = [];
+            bytes = 0;
+        };
+        for (const unit of members.sort((left, right) => left.fileName.localeCompare(right.fileName))) {
+            const size = Buffer.byteLength(unit.source, 'utf8');
+            if (group.length >= 16 || bytes + size > 64 * 1024)
+                publish();
+            group.push(unit);
+            bytes += size;
+        }
+        publish();
+    }
+    return result;
+};

package/dist/targets/cpp/borrowed-call-entry.d.ts

@@ -0,0 +1,30 @@
+import type { FunctionId, IrValueId } from '../../identity/ids.js';
+import { type PrivateBorrowCell } from '../../ir/borrowed-call-arguments.js';
+import type { IrBody, IrOperand } from '../../ir/model.js';
+import { type CallableAbi } from '../../representation/model.js';
+/** The original body name remains an owning entry wrapper. This additional
+ * entry is internal and may be selected only with stable-actual evidence.
+ * No callable's public ABI or thunk identity names the borrowed body. */
+export interface StableBorrowEntry {
+    readonly owner: FunctionId;
+    readonly name: string;
+    readonly abi: CallableAbi;
+    readonly formals: ReadonlySet<number>;
+}
+export declare const stableBorrowEntryOf: (body: IrBody, owner: FunctionId, privateCell: PrivateBorrowCell, originalBorrowed: ReadonlySet<number>, dyingArguments: ReadonlySet<IrValueId>, bodyCallsUnsafeKnownCallee: boolean, admission: {
+    readonly captureFree: boolean;
+    readonly synchronous: boolean;
+    readonly singleBody: boolean;
+    readonly unchangedNumericAbi: boolean;
+}) => StableBorrowEntry | null;
+/** A private caller slot survives arbitrary program re-entry. All extra
+ * reference formals must bind such slots; otherwise use the existing owning
+ * entry, whose snapshots bind the borrowed implementation safely.
+ *
+ * Reject mixed move/borrow evaluation: C++ may evaluate an owning sibling's
+ * std::move before another argument binds a reference to the same slot.
+ * Conservatively reject ANY potentially moving reference sibling rather than
+ * claiming an alias distinction the emitter's deferred expressions may erase.
+ * Scalars cannot move a string/handle slot. Binding a borrowed formal does
+ * not itself move from its argument. */
+export declare const stableBorrowEntryAccepts: (entry: StableBorrowEntry, actuals: readonly IrOperand[], stable: ReadonlySet<IrValueId>, dyingArguments: ReadonlySet<IrValueId>) => boolean;

package/dist/targets/cpp/borrowed-call-entry.js

@@ -0,0 +1,68 @@
+import { readonlyBorrowFormalsOf } from '../../ir/borrowed-call-arguments.js';
+import { passingOf, representationKey } from '../../representation/model.js';
+import { cppBodyName } from './types.js';
+export const stableBorrowEntryOf = (body, owner, privateCell, originalBorrowed, dyingArguments, bodyCallsUnsafeKnownCallee, admission) => {
+    const abi = body.abi;
+    if (body.sourceOwner !== owner ||
+        !admission.captureFree ||
+        !admission.synchronous ||
+        !admission.singleBody ||
+        !admission.unchangedNumericAbi)
+        return null;
+    // A receiver is not disqualifying: `signatureOf`/`bodyFormalsOf` already
+    // spell a method's `this` from `borrowsReceiver`, independently of the
+    // `formals` this function returns, so a method's OWN non-receiver formals
+    // are exactly as eligible for the extra reference entry as a free
+    // function's. `readonlyBorrowFormalsOf` below never inspects `abi.receiver`
+    // either -- it only walks `parameter` operations, which never include the
+    // receiver. `restFrom` stays excluded: a rest parameter's actual is an
+    // Array the caller built for this call alone, never a stable binding.
+    if (!abi || abi.restFrom !== null)
+        return null;
+    // A body that calls a RESOLVABLE callee never proven effect-safe can have
+    // that callee write through one of this body's own other parameters --
+    // `snapshot(text, holder) { middle(holder); return text }`, where `middle`
+    // writes `holder.text`. `readonlyBorrowFormalsOf` looks at binding writes
+    // only and cannot see a transitive one, so the disqualification is asked
+    // here, of the whole-program fact that already knows the call graph.
+    //
+    // Deliberately restricted to a KNOWN callee. An opaque one -- a callback
+    // arriving as a parameter value, with no resolvable target -- is a hazard
+    // for the CALLER to rule out against the actual it supplies
+    // (`stableBorrowEntryAccepts` below), and disqualifying the entry here
+    // instead would withdraw the fast path from every higher-order body whose
+    // callers can prove their actuals stable.
+    if (bodyCallsUnsafeKnownCallee)
+        return null;
+    const readonly = readonlyBorrowFormalsOf(body, privateCell, dyingArguments);
+    const formals = new Set([...readonly].filter((ordinal) => abi.parameters[ordinal]?.passing === 'const-ref'));
+    if (![...formals].some((ordinal) => !originalBorrowed.has(ordinal)))
+        return null;
+    // Never revoke an established, stronger effect-based borrow proof.
+    for (const ordinal of originalBorrowed)
+        formals.add(ordinal);
+    return { owner, name: `${cppBodyName(owner)}_stable_borrow`, abi, formals };
+};
+/** A private caller slot survives arbitrary program re-entry. All extra
+ * reference formals must bind such slots; otherwise use the existing owning
+ * entry, whose snapshots bind the borrowed implementation safely.
+ *
+ * Reject mixed move/borrow evaluation: C++ may evaluate an owning sibling's
+ * std::move before another argument binds a reference to the same slot.
+ * Conservatively reject ANY potentially moving reference sibling rather than
+ * claiming an alias distinction the emitter's deferred expressions may erase.
+ * Scalars cannot move a string/handle slot. Binding a borrowed formal does
+ * not itself move from its argument. */
+export const stableBorrowEntryAccepts = (entry, actuals, stable, dyingArguments) => {
+    for (const ordinal of entry.formals) {
+        const actual = actuals[ordinal];
+        const formal = entry.abi.parameters[ordinal];
+        if (!actual || !formal || !stable.has(actual.value))
+            return false;
+        // Conversion expressions can expose a different physical lifetime. Admit
+        // only the exact carried input; other calls retain their owning adapter.
+        if (representationKey(actual.representation) !== representationKey(formal.value))
+            return false;
+    }
+    return actuals.every((actual, ordinal) => entry.formals.has(ordinal) || !dyingArguments.has(actual.value) || passingOf(actual.representation) !== 'const-ref');
+};

package/dist/targets/cpp/captures.d.ts

@@ -0,0 +1,68 @@
+import type { DeclarationId, FunctionId } from '../../identity/ids.js';
+import type { IrBody } from '../../ir/model.js';
+import type { BindingPlacement } from '../../projection/bindings.js';
+import type { CaptureIndex } from './emit-context.js';
+/**
+ * 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 declare const buildCaptureIndex: (bodies: readonly IrBody[], placements: ReadonlyMap<DeclarationId, BindingPlacement>, capturingAccessors?: ReadonlySet<FunctionId>) => CaptureIndex;
+/**
+ * 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 declare const buildDirectCallableIndex: (bodies: readonly IrBody[], captures: CaptureIndex, placements: ReadonlyMap<DeclarationId, BindingPlacement>) => ReadonlyMap<DeclarationId, FunctionId>;