@geastack/compiler 1.0.15

package/dist/semantics/normalize/structural-leaves.d.ts

@@ -0,0 +1,49 @@
+import ts from 'typescript';
+import type { PropertyKeyShape, StructuralShape } from '../model/structural-types.js';
+import type { IdentityTable } from './identities.js';
+/**
+ * A `ts.Type` that is a leaf: it maps straight to its shape with no walk.
+ *
+ * These three answers share one property that earns them a file of their own --
+ * none of them can recur. A primitive, a literal, and a property key are
+ * terminal by construction, so none needs the interning table, the in-progress
+ * set, or the self-reference machinery the rest of the mapper is built around.
+ * Keeping them out of that closure keeps the fact that they cannot participate
+ * in a cycle visible in the code rather than merely true of it.
+ */
+export declare const primitiveFor: (type: ts.Type) => StructuralShape | null;
+export declare const literalFor: (type: ts.Type) => StructuralShape | null;
+/**
+ * The declaration a symbol-named member's key is anchored to: the SYMBOL's own
+ * declaration, reached through the member's computed name.
+ *
+ * `class C { [GEA_DISPOSER]: D }` declares a member whose key is
+ * `GEA_DISPOSER`, and the member declaration is not that key -- it is a
+ * *use* of it. Anchoring on the member would give two classes that declare
+ * the same symbol-named member two different keys, and `keyof.ts` already
+ * assumes the opposite: it turns a member key straight into
+ * `{ kind: 'unique-symbol', declaration }`, which `structural.ts`'s own
+ * `UniqueESSymbol` branch mints from the SYMBOL's declaration. Two spellings
+ * of one identity is exactly the drift this compiler refuses elsewhere, and
+ * here it is load-bearing: `records.ts` names the struct member
+ * `gea_sym_<declaration>` while `producers/properties.ts` resolves
+ * `this[GEA_DISPOSER]` through the same text, so a disagreement is a field
+ * write that lands on a member no read finds.
+ *
+ * `null` when the member has no computed name to resolve through -- a
+ * synthesized or late-bound symbol with no declaration -- and the caller falls
+ * back to the member's own declaration, which is still a stable identity, just
+ * a per-declaration one.
+ */
+export declare const symbolKeyDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, member: ts.Symbol) => ts.Declaration | null;
+/**
+ * The shape of the property key a symbol declares.
+ *
+ * A well-known symbol member arrives with the checker's own `__@`-prefixed
+ * name, which is not the key -- the key is the symbol's declaration, so the
+ * shape cites that instead of the mangled spelling. A numeric name is a number
+ * key only when it round-trips exactly, so `'01'` and `'1.5'` stay string keys.
+ */
+export declare const createLeafKeying: (identities: IdentityTable, checker: ts.TypeChecker) => {
+    keyOfSymbol: (symbol: ts.Symbol) => PropertyKeyShape | null;
+};

package/dist/semantics/normalize/structural-leaves.js

@@ -0,0 +1,125 @@
+import ts from 'typescript';
+/**
+ * A `ts.Type` that is a leaf: it maps straight to its shape with no walk.
+ *
+ * These three answers share one property that earns them a file of their own --
+ * none of them can recur. A primitive, a literal, and a property key are
+ * terminal by construction, so none needs the interning table, the in-progress
+ * set, or the self-reference machinery the rest of the mapper is built around.
+ * Keeping them out of that closure keeps the fact that they cannot participate
+ * in a cycle visible in the code rather than merely true of it.
+ */
+export const primitiveFor = (type) => {
+    const flags = type.flags;
+    if (flags & ts.TypeFlags.Never)
+        return { kind: 'primitive', primitive: 'never' };
+    if (flags & ts.TypeFlags.Void)
+        return { kind: 'primitive', primitive: 'void' };
+    if (flags & ts.TypeFlags.Undefined)
+        return { kind: 'primitive', primitive: 'undefined' };
+    if (flags & ts.TypeFlags.Null)
+        return { kind: 'primitive', primitive: 'null' };
+    if (flags & ts.TypeFlags.BooleanLiteral)
+        return { kind: 'primitive', primitive: 'boolean' };
+    if (flags & ts.TypeFlags.Boolean)
+        return { kind: 'primitive', primitive: 'boolean' };
+    if (flags & ts.TypeFlags.Number)
+        return { kind: 'primitive', primitive: 'number' };
+    if (flags & ts.TypeFlags.BigInt)
+        return { kind: 'primitive', primitive: 'bigint' };
+    if (flags & ts.TypeFlags.String)
+        return { kind: 'primitive', primitive: 'string' };
+    // A template-literal type (`` `${number}%` ``) and a string-mapping type
+    // (`Uppercase<T>`) are constraints on which strings a value may be, not a
+    // separate kind of value: every inhabitant is a string, and the constraint is
+    // checked by the checker and then has nothing left to say about storage. They
+    // are deliberately not `literal` shapes -- a literal names one exact value a
+    // union can be discriminated on, and these name a set -- so the honest answer
+    // is the primitive they inhabit. Without this a `style={{ width: `${n}%` }}`
+    // reaches representation as an unmodelled checker type and takes the whole
+    // enclosing object literal down with it.
+    if (flags & (ts.TypeFlags.TemplateLiteral | ts.TypeFlags.StringMapping))
+        return { kind: 'primitive', primitive: 'string' };
+    if (flags & ts.TypeFlags.ESSymbol)
+        return { kind: 'primitive', primitive: 'symbol' };
+    if (flags & ts.TypeFlags.Unknown)
+        return { kind: 'primitive', primitive: 'unknown' };
+    if (flags & ts.TypeFlags.Any)
+        return { kind: 'primitive', primitive: 'any' };
+    return null;
+};
+export const literalFor = (type) => {
+    if (type.isStringLiteral())
+        return { kind: 'literal', primitive: 'string', text: type.value };
+    if (type.isNumberLiteral())
+        return { kind: 'literal', primitive: 'number', text: String(type.value) };
+    if (type.flags & ts.TypeFlags.BigIntLiteral) {
+        const literal = type.value;
+        return { kind: 'literal', primitive: 'bigint', text: `${literal.negative ? '-' : ''}${literal.base10Value}` };
+    }
+    return null;
+};
+/**
+ * The declaration a symbol-named member's key is anchored to: the SYMBOL's own
+ * declaration, reached through the member's computed name.
+ *
+ * `class C { [GEA_DISPOSER]: D }` declares a member whose key is
+ * `GEA_DISPOSER`, and the member declaration is not that key -- it is a
+ * *use* of it. Anchoring on the member would give two classes that declare
+ * the same symbol-named member two different keys, and `keyof.ts` already
+ * assumes the opposite: it turns a member key straight into
+ * `{ kind: 'unique-symbol', declaration }`, which `structural.ts`'s own
+ * `UniqueESSymbol` branch mints from the SYMBOL's declaration. Two spellings
+ * of one identity is exactly the drift this compiler refuses elsewhere, and
+ * here it is load-bearing: `records.ts` names the struct member
+ * `gea_sym_<declaration>` while `producers/properties.ts` resolves
+ * `this[GEA_DISPOSER]` through the same text, so a disagreement is a field
+ * write that lands on a member no read finds.
+ *
+ * `null` when the member has no computed name to resolve through -- a
+ * synthesized or late-bound symbol with no declaration -- and the caller falls
+ * back to the member's own declaration, which is still a stable identity, just
+ * a per-declaration one.
+ */
+export const symbolKeyDeclarationOf = (checker, identities, member) => {
+    for (const declaration of member.getDeclarations() ?? []) {
+        const name = declaration.name;
+        if (!name || !ts.isComputedPropertyName(name))
+            continue;
+        const keySymbol = checker.getSymbolAtLocation(name.expression);
+        // Through `identities`, never `keySymbol.getDeclarations()` directly: the
+        // name expression is an imported identifier in every real case, so the
+        // symbol at that location is the IMPORT SPECIFIER and its first
+        // declaration is the import statement in the consuming file. Two files
+        // importing one symbol would then anchor its key on two different
+        // declarations. `declarationOfSymbol` follows the alias to the `const`
+        // itself, which is exactly the anchor `structural.ts`'s `UniqueESSymbol`
+        // branch mints for the key expression's own type.
+        const resolved = keySymbol ? identities.declarationOfSymbol(keySymbol) : null;
+        if (resolved)
+            return resolved;
+    }
+    return null;
+};
+/**
+ * The shape of the property key a symbol declares.
+ *
+ * A well-known symbol member arrives with the checker's own `__@`-prefixed
+ * name, which is not the key -- the key is the symbol's declaration, so the
+ * shape cites that instead of the mangled spelling. A numeric name is a number
+ * key only when it round-trips exactly, so `'01'` and `'1.5'` stay string keys.
+ */
+export const createLeafKeying = (identities, checker) => {
+    const keyOfSymbol = (symbol) => {
+        const name = symbol.getName();
+        if (name.startsWith('__@')) {
+            const declaration = symbolKeyDeclarationOf(checker, identities, symbol) ?? identities.declarationOfSymbol(symbol);
+            return declaration ? { kind: 'symbol', declaration: identities.declarationIdOf(declaration) } : null;
+        }
+        const asIndex = Number(name);
+        if (String(asIndex) === name && Number.isInteger(asIndex) && asIndex >= 0)
+            return { kind: 'number', value: asIndex };
+        return { kind: 'string', value: name };
+    };
+    return { keyOfSymbol };
+};

package/dist/semantics/normalize/structural-local-union.d.ts

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import type { StructuralTypeId } from '../../identity/ids.js';
+import type { StructuralTypeTable } from '../model/structural-type-table.js';
+import type { ValueFlowIndex } from './flow/model.js';
+import type { ParameterBindingCensus } from './parameter-bindings.js';
+/**
+ * Complete a synthesized local union in the SAME specialization view as its
+ * writes. A ts.Type member list can still contain erased positions (Function
+ * inside a parameter tuple); the source expression's structural type already
+ * has their physical callable signatures. Storing that value must not erase it
+ * back to Function. The flow index supplies every write, never a syntax scan.
+ */
+export declare const createLocalUnionResolver: (checker: ts.TypeChecker, table: StructuralTypeTable, census: ParameterBindingCensus, flow: ValueFlowIndex | undefined, read: (node: ts.Node) => StructuralTypeId, refinedSourceAt?: (node: ts.Node) => StructuralTypeId | null) => ((node: ts.Node) => StructuralTypeId | null);

package/dist/semantics/normalize/structural-local-union.js

@@ -0,0 +1,133 @@
+import ts from 'typescript';
+import { containsUnstatedPosition } from './derived-expression-type.js';
+/**
+ * Complete a synthesized local union in the SAME specialization view as its
+ * writes. A ts.Type member list can still contain erased positions (Function
+ * inside a parameter tuple); the source expression's structural type already
+ * has their physical callable signatures. Storing that value must not erase it
+ * back to Function. The flow index supplies every write, never a syntax scan.
+ */
+export const createLocalUnionResolver = (checker, table, census, flow, read, refinedSourceAt = () => null) => {
+    const memo = new Map();
+    const pending = new Set();
+    const sourceRefined = new Set();
+    const concreteRefinement = (id, visited = new Set()) => {
+        if (visited.has(id))
+            return true;
+        visited.add(id);
+        const shape = table.get(id).shape;
+        if (shape.kind === 'primitive')
+            return shape.primitive !== 'any' && shape.primitive !== 'unknown';
+        if (shape.kind === 'union')
+            return shape.members.every((member) => concreteRefinement(member, visited));
+        if (shape.kind === 'object')
+            return shape.members.every((member) => concreteRefinement(member.type, visited));
+        return shape.kind !== 'unresolved';
+    };
+    const resolve = (declaration) => {
+        if (!flow || declaration.type || !ts.isIdentifier(declaration.name))
+            return null;
+        if (memo.has(declaration))
+            return memo.get(declaration) ?? null;
+        if (pending.has(declaration))
+            return null;
+        const writes = flow.writesToDeclaration(declaration).filter((write) => write.slot === 'whole');
+        if (!writes.length ||
+            writes.some((write) => !write.value || (write.edge !== 'declaration-initializer' && write.edge !== 'identifier-assignment')))
+            return null;
+        // Some authenticated intrinsic calls publish a more precise structural
+        // result than their non-generic ambient signature. Its unannotated local
+        // must retain that same carrier. Reuse the complete write set, requiring
+        // every incoming source to establish the identical concrete refinement;
+        // one unknown or incompatible writer prevents partial narrowing.
+        pending.add(declaration);
+        const unionArms = census.unionArmsAt(declaration);
+        if (!unionArms) {
+            const refinements = writes.map((write) => refinedSourceAt(write.value));
+            const first = refinements[0];
+            if (!first || refinements.some((id) => id !== first) || !concreteRefinement(first)) {
+                pending.delete(declaration);
+                return null;
+            }
+            sourceRefined.add(declaration);
+        }
+        const members = writes.map((write) => read(write.value));
+        pending.delete(declaration);
+        // An uninitialized lexical binding holds undefined until its first write.
+        if (!declaration.initializer)
+            members.push(table.intern({ kind: 'primitive', primitive: 'undefined' }));
+        const result = table.intern({ kind: 'union', members });
+        memo.set(declaration, result);
+        return result;
+    };
+    return (node) => {
+        if (ts.isVariableDeclaration(node))
+            return resolve(node);
+        if (!ts.isIdentifier(node))
+            return null;
+        const declarations = checker.getSymbolAtLocation(node)?.declarations;
+        const declaration = declarations?.length === 1 ? declarations[0] : undefined;
+        if (!declaration || !ts.isVariableDeclaration(declaration))
+            return null;
+        // Resolve the narrow candidate before asking the checker for this read's
+        // potentially enormous instantiated type. Almost every identifier is not
+        // such a candidate; querying all of them overflowed TypeScript's own
+        // conditional-type instantiation stack on Hono's route types.
+        const result = resolve(declaration);
+        if (!result || node === declaration.name)
+            return result;
+        // Calling a union-held local does not first convert the cell into the
+        // checker's common signature. The callable value remains whichever arm
+        // was stored, and [[Call]] dispatches through that arm's own convention.
+        // Preserve the physical union at the direct callee site so the invocation
+        // lowering can perform its existing per-arm dispatch, including dropping
+        // arguments for a zero-parameter arm. Any non-callable or incompatible
+        // arm still fails closed in that lowering.
+        if (ts.isCallExpression(node.parent) && node.parent.expression === node)
+            return result;
+        const raw = checker.getTypeAtLocation(node);
+        // `Array.isArray(local)` deliberately narrows the true branch to `any[]`,
+        // even when this census already knows the local's sole array write arm and
+        // its concrete element type. The predicate selects that existing arm; it
+        // neither allocates a new Array<any> nor converts the elements. Recover it
+        // from the physical write union when exactly one array carrier is possible.
+        // A union with two array arms remains ambiguous and keeps the checker's
+        // view, as does a genuinely declared any[] cell whose physical shape is
+        // already just that array.
+        if (checker.isArrayType(raw)) {
+            const [element] = checker.getTypeArguments(raw);
+            const shape = table.get(result).shape;
+            if (element && (element.flags & ts.TypeFlags.Any) !== 0 && shape.kind === 'union') {
+                const arrays = shape.members.filter((id) => table.get(id).shape.kind === 'array');
+                if (arrays.length === 1)
+                    return arrays[0] ?? null;
+            }
+        }
+        // A real flow narrowing keeps its own type. An erased Function/any at a
+        // read is not such a narrowing, but may still prove nullish exclusion.
+        if (!sourceRefined.has(declaration) && !containsUnstatedPosition(checker, node, raw))
+            return null;
+        if ((raw.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)
+            return result;
+        if ((raw.flags & ts.TypeFlags.Undefined) !== 0)
+            return table.intern({ kind: 'primitive', primitive: 'undefined' });
+        if ((raw.flags & ts.TypeFlags.Null) !== 0)
+            return table.intern({ kind: 'primitive', primitive: 'null' });
+        const shape = table.get(result).shape;
+        if (shape.kind !== 'union')
+            return result;
+        const rawMembers = raw.isUnion() ? raw.types : [raw];
+        const allows = (flag) => rawMembers.some((member) => (member.flags & flag) !== 0);
+        const kept = shape.members.filter((id) => {
+            const member = table.get(id).shape;
+            if (member.kind !== 'primitive')
+                return true;
+            if (member.primitive === 'undefined')
+                return allows(ts.TypeFlags.Undefined);
+            if (member.primitive === 'null')
+                return allows(ts.TypeFlags.Null);
+            return true;
+        });
+        return kept.length === 1 ? (kept[0] ?? null) : table.intern({ kind: 'union', members: kept });
+    };
+};

package/dist/semantics/normalize/structural-members.d.ts

@@ -0,0 +1,26 @@
+import ts from 'typescript';
+import type { IdentityTable } from './identities.js';
+/**
+ * Which members of an object type a LAYOUT carries.
+ *
+ * Three modes, and the difference between them is the whole subject of this
+ * file:
+ *
+ * - `all` -- an in-program object literal or a non-ambient declaration. Every
+ *   member is written in this program, so every member is storage.
+ * - `data-only` -- a CLASS instance, and a declarationless object type. A class
+ *   method lives on the prototype; putting it in the instance would claim
+ *   per-instance storage the language does not allocate. (`typeof globalThis`
+ *   needs the same filter for an unrelated reason: its own `globalThis`
+ *   property mentions the type again, and the ambient `var`/`function` bindings
+ *   at global scope are checker-flagged `Module`, not `Property`, so filtering
+ *   to `Property` is what keeps that walk finite.)
+ * - `interface` -- an ambient interface or type alias. See `keeperFor`.
+ */
+export type MemberMode = 'all' | 'data-only' | 'interface';
+/** Which of the two filters a mode selects, given the full member list it will be applied to. */
+export type MemberKeeper = (properties: readonly ts.Symbol[], members: 'data-only' | 'interface') => (property: ts.Symbol) => boolean;
+/** The member rules, bound to the identity table they need to read declarations from. */
+export declare const createMemberRules: (identities: IdentityTable) => {
+    readonly keeperFor: MemberKeeper;
+};

package/dist/semantics/normalize/structural-members.js

@@ -0,0 +1,84 @@
+import ts from 'typescript';
+/** The member rules, bound to the identity table they need to read declarations from. */
+export const createMemberRules = (identities) => {
+    const declarationOfSymbol = (property) => identities.declarationOfSymbol(property);
+    const isDataMember = (property) => (property.flags & ts.SymbolFlags.Property) !== 0;
+    /**
+     * A method no layout can carry a slot for.
+     *
+     * Three reasons, each fail-closed:
+     *
+     * GENERIC. This is the member `data-only` was written to exclude, and the
+     * exclusion is about termination, not implementation: every instantiation of
+     * `Promise.then<TResult1, TResult2>` mints a fresh anchor whose return type
+     * is a fresh `Promise` of fresh parameters, so walking one never converges.
+     *
+     * OVERLOADED. A symbol with more than one declaration has more than one call
+     * signature, and a field holding it would have to name ONE calling
+     * convention. `RegExp`'s `[Symbol.replace]`
+     * (`lib.es2015.symbol.wellknown.d.ts`) is the standing case: two signatures
+     * differing in whether `replaceValue` is a string or a callback. Carrying it
+     * reached the emitter as `unresolved(no primitive joining 2 overload
+     * signatures into one calling convention)` and refused the whole record
+     * layout -- a member the layout cannot name is not a member the layout can
+     * hold, and the honest place to refuse is the USE, which already does.
+     *
+     * UNIDENTIFIABLE. A symbol whose declaration cannot be found answers no
+     * question at all; treating it as uncarriable keeps the walk finite.
+     */
+    const isUncarriableMethod = (property) => {
+        if ((property.getDeclarations()?.length ?? 0) > 1)
+            return true;
+        const declaration = declarationOfSymbol(property);
+        if (declaration === null)
+            return true;
+        if (!ts.isMethodSignature(declaration) && !ts.isMethodDeclaration(declaration))
+            return true;
+        return (declaration.typeParameters?.length ?? 0) > 0;
+    };
+    /**
+     * A member an ambient *interface* contributes to the layout.
+     *
+     * `Property` plus every NON-generic method. An interface has no
+     * implementation to be missing -- it names a shape, and whoever creates a
+     * value of it supplies the members. A program that does supply one stores a
+     * callable into that slot: `core/packages/core/runtime/host.ts` builds
+     * `const photo: CameraPhoto = { imageId, width, height, orientation,
+     * dispose() { image.dispose(id) } }` against an interface declared in
+     * `core/packages/core/index.d.ts`. Filtering `dispose` out left the
+     * allocation writing a field the record type did not declare -- the
+     * object-literal walk and the layout disagreeing, with the layout wrong.
+     *
+     * Methods no layout can name a slot for stay filtered -- see
+     * `isUncarriableMethod`. This is deliberately NOT the rule for
+     * a class instance: a class method lives on the prototype, so `isDataMember`
+     * alone stays correct there and claiming per-instance storage for it would be
+     * a second, opposite defect.
+     */
+    const isInterfaceMember = (property) => isDataMember(property) || ((property.flags & ts.SymbolFlags.Method) !== 0 && !isUncarriableMethod(property));
+    /**
+     * Whether an interface's methods can be carried AS A SET.
+     *
+     * All or none, deliberately. A layout either represents the interface
+     * faithfully or it is the data-only projection; keeping some methods and
+     * silently dropping others is neither, and it is actively worse than either
+     * -- it grows the struct with members whose siblings are missing, so the
+     * shape claims to be the interface while answering a different member set.
+     *
+     * The two cases this separates are real. `CameraPhoto`
+     * (`core/packages/core/index.d.ts`) is four data properties and one plain
+     * `dispose(): void`: nothing is dropped, every member is storage, and an
+     * object literal in `runtime/host.ts` really does write all five. `RegExp`
+     * (`lib.es5.d.ts`) is the opposite -- `[Symbol.replace]` is overloaded,
+     * others are generic -- so its layout is a projection no matter what, and
+     * admitting `exec`/`test` into it only dragged `RegExpExecArray` and
+     * `RegExpMatchArray` in behind them as native handles for protocols nothing
+     * claims. A builtin whose values are not object literals belongs behind a
+     * native protocol (v1 carries `RegExp` as `gea::runtime::regex::Pattern`),
+     * not in a record; until it is, the data-only projection is the honest
+     * answer for it, and this rule reaches that answer without naming it.
+     */
+    const methodsAreCarriable = (properties) => properties.every((property) => (property.flags & ts.SymbolFlags.Method) === 0 || !isUncarriableMethod(property));
+    const keeperFor = (properties, members) => members === 'interface' && methodsAreCarriable(properties) ? isInterfaceMember : isDataMember;
+    return { keeperFor };
+};

package/dist/semantics/normalize/structural-mutable-method.d.ts

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+import type { StructuralTypeId } from '../../identity/ids.js';
+import type { StructuralTypeTable } from '../model/structural-type-table.js';
+import type { SignatureShape } from '../model/structural-types.js';
+import type { ValueFlowIndex } from './flow/model.js';
+/** A mutable method is a storage cell, not its initial function body. Its
+ * public frame must transport the arguments consumed by every published
+ * replacement. Shorter implementations ignore the unused suffix through the
+ * ordinary certified callable adapter. The inventory is the shared flow
+ * index; neither member reads nor invocation producers rescan assignments.
+ */
+export declare const createMutableMethodResolver: (checker: ts.TypeChecker, table: StructuralTypeTable, flow: ValueFlowIndex | undefined, signatureOf: (signature: ts.Signature) => SignatureShape, read: (node: ts.Node) => StructuralTypeId, receiverTypeAt: (node: ts.Expression) => ts.Type) => {
+    readonly storageTypeAt: (node: ts.MethodDeclaration) => StructuralTypeId | null;
+    readonly readTypeAt: (node: ts.Node) => StructuralTypeId | null;
+};

package/dist/semantics/normalize/structural-mutable-method.js

@@ -0,0 +1,109 @@
+import ts from 'typescript';
+import { structuralCallSignatures } from './structural-callable.js';
+/** A mutable method is a storage cell, not its initial function body. Its
+ * public frame must transport the arguments consumed by every published
+ * replacement. Shorter implementations ignore the unused suffix through the
+ * ordinary certified callable adapter. The inventory is the shared flow
+ * index; neither member reads nor invocation producers rescan assignments.
+ */
+export const createMutableMethodResolver = (checker, table, flow, signatureOf, read, receiverTypeAt) => {
+    const cache = new Map();
+    const pending = new Set();
+    const resolve = (symbol) => {
+        if (cache.has(symbol))
+            return cache.get(symbol) ?? null;
+        if (!flow || pending.has(symbol))
+            return null;
+        const declarations = symbol.declarations ?? [];
+        const methods = declarations.filter(ts.isMethodDeclaration);
+        const body = methods.find((method) => method.body !== undefined);
+        if (!body || methods.some((method) => method.parent !== body.parent))
+            return null;
+        if (ts.getCombinedModifierFlags(body) & ts.ModifierFlags.Static)
+            return null;
+        const writes = new Set([
+            ...flow.writesToSymbol(symbol),
+            ...declarations.flatMap((declaration) => flow.writesToDeclaration(declaration))
+        ]);
+        const replacements = [...writes].filter((write) => write.slot === 'whole' || write.slot === 'member');
+        if (!replacements.some((write) => write.value !== null))
+            return null;
+        pending.add(symbol);
+        try {
+            const original = checker.getSignatureFromDeclaration(body);
+            if (!original)
+                return null;
+            const initial = signatureOf(original);
+            const signatures = checker
+                .getTypeOfSymbolAtLocation(symbol, body)
+                .getCallSignatures()
+                .map((signature) => signatureOf(signature));
+            for (const write of replacements) {
+                if (!write.value)
+                    continue;
+                const alternatives = structuralCallSignatures(table, read(write.value));
+                // An unknown/noncallable replacement cannot be represented by a
+                // fabricated native function frame. Leave its existing refusal intact.
+                if (!alternatives)
+                    return null;
+                signatures.push(...alternatives);
+            }
+            if (!signatures.length)
+                return null;
+            const widest = signatures.reduce((held, next) => (next.parameters.length > held.parameters.length ? next : held));
+            // Rest tails have independent positional semantics; never manufacture a
+            // fixed frame by truncating one. Equal frames need no new authority.
+            if (signatures.some((signature) => signature.parameters.some((parameter) => parameter.rest)))
+                return null;
+            const join = (values) => {
+                const members = [...new Set(values)];
+                return members.length === 1 ? members[0] : table.intern({ kind: 'union', members });
+            };
+            const result = table.intern({
+                kind: 'signature',
+                construct: [],
+                call: [
+                    {
+                        ...widest,
+                        thisParameter: initial.thisParameter,
+                        result: join(signatures.map((signature) => signature.result)),
+                        parameters: widest.parameters.map((parameter, ordinal) => {
+                            const present = signatures.flatMap((signature) => (signature.parameters[ordinal] ? [signature.parameters[ordinal]] : []));
+                            return {
+                                ...parameter,
+                                type: join(present.map((entry) => entry.type)),
+                                slot: join(present.map((entry) => entry.slot))
+                            };
+                        })
+                    }
+                ]
+            });
+            cache.set(symbol, result);
+            return result;
+        }
+        finally {
+            pending.delete(symbol);
+        }
+    };
+    return {
+        storageTypeAt: (node) => {
+            const symbol = checker.getSymbolAtLocation(node.name);
+            return symbol ? resolve(symbol) : null;
+        },
+        readTypeAt: (node) => {
+            if (!ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
+                return null;
+            const key = ts.isPropertyAccessExpression(node)
+                ? node.name.text
+                : ts.isStringLiteralLike(node.argumentExpression) || ts.isNumericLiteral(node.argumentExpression)
+                    ? node.argumentExpression.text
+                    : null;
+            // A JS parameter can be checker-any while the settled parameter census
+            // proves its class. Ask that same receiver authority for the member;
+            // otherwise a call inside a helper silently rediscovers the old body ABI.
+            const symbol = checker.getSymbolAtLocation(ts.isPropertyAccessExpression(node) ? node.name : node) ??
+                (key === null ? undefined : checker.getPropertyOfType(checker.getApparentType(receiverTypeAt(node.expression)), key));
+            return symbol ? resolve(symbol) : null;
+        }
+    };
+};