@geastack/compiler 1.0.15

package/dist/semantics/normalize/flow/source-class-instanceof.d.ts

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+/**
+ * Shape half of the ordinary instanceof protocol proof. The caller must also
+ * prove the constructor family's references closed: definitions cannot show
+ * later defineProperty/setPrototypeOf calls or constructor escapes.
+ *
+ * Every source class initially inherits the realm's Function.prototype hook.
+ * That intrinsic own property is nonwritable and nonconfigurable. Replacing a
+ * global Function binding, or changing Function.prototype's parent, cannot
+ * change it. Source static computed members can shadow it, so admit only keys
+ * proven to be strings/numbers; unknown and symbol keys remain conservative.
+ */
+export declare const sourceClassHasDefaultInstanceOfShape: (checker: ts.TypeChecker, instance: ts.InterfaceType) => boolean;

package/dist/semantics/normalize/flow/source-class-instanceof.js

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+import { heritageClassOrInterfaceOf } from './model.js';
+/**
+ * Shape half of the ordinary instanceof protocol proof. The caller must also
+ * prove the constructor family's references closed: definitions cannot show
+ * later defineProperty/setPrototypeOf calls or constructor escapes.
+ *
+ * Every source class initially inherits the realm's Function.prototype hook.
+ * That intrinsic own property is nonwritable and nonconfigurable. Replacing a
+ * global Function binding, or changing Function.prototype's parent, cannot
+ * change it. Source static computed members can shadow it, so admit only keys
+ * proven to be strings/numbers; unknown and symbol keys remain conservative.
+ */
+export const sourceClassHasDefaultInstanceOfShape = (checker, instance) => {
+    const seen = new Set();
+    const nonSymbolKey = (type) => type.isUnion() ? type.types.every(nonSymbolKey) : (type.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike)) !== 0;
+    const visit = (type) => {
+        if (seen.has(type))
+            return false;
+        seen.add(type);
+        const owner = type.getSymbol()?.valueDeclaration;
+        if (!owner || (!ts.isClassDeclaration(owner) && !ts.isClassExpression(owner)) || owner.getSourceFile().isDeclarationFile)
+            return false;
+        for (const member of owner.members) {
+            if ((ts.getCombinedModifierFlags(member) & ts.ModifierFlags.Static) === 0 || !member.name || !ts.isComputedPropertyName(member.name))
+                continue;
+            if (!nonSymbolKey(checker.getTypeAtLocation(member.name.expression)))
+                return false;
+        }
+        const bases = checker.getBaseTypes(type) ?? [];
+        return bases.every((base) => {
+            const declared = heritageClassOrInterfaceOf(base);
+            return declared !== null && visit(declared);
+        });
+    };
+    return visit(instance);
+};

package/dist/semantics/normalize/flow/source-class-static-data.d.ts

@@ -0,0 +1,16 @@
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+/** A constructor's data field is a separate value, not a publication of the
+ * constructor. The caller still checks every constructor reference, which
+ * rejects descriptor/prototype mutation and ordinary constructor aliases.
+ * Static `this` captures and callable values need receiver-flow evidence and
+ * cannot use this data-only path.
+ *
+ * Data-ness is judged by the values actually written, never by the declared
+ * type. Because the caller has explained every mention of the constructor,
+ * no alias can store into the static, so its named writes are all it holds.
+ * A declared type only states what a write MAY store: three's
+ * `@type {?Image} Texture.DEFAULT_IMAGE = null` names a constructor type that
+ * no write realises.
+ */
+export declare const sourceClassStaticDataUseOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, reference: ts.Expression) => boolean;

package/dist/semantics/normalize/flow/source-class-static-data.js

@@ -0,0 +1,47 @@
+import ts from 'typescript';
+/** A value no call or construction can invoke. `object` is refused with
+ * `any`: it admits every function, so it cannot vouch that the value is data. */
+const dataValue = (type) => type.isUnion()
+    ? type.types.every(dataValue)
+    : (type.flags &
+        (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter | ts.TypeFlags.Never | ts.TypeFlags.NonPrimitive)) ===
+        0 &&
+        type.getCallSignatures().length === 0 &&
+        type.getConstructSignatures().length === 0;
+/** A constructor's data field is a separate value, not a publication of the
+ * constructor. The caller still checks every constructor reference, which
+ * rejects descriptor/prototype mutation and ordinary constructor aliases.
+ * Static `this` captures and callable values need receiver-flow evidence and
+ * cannot use this data-only path.
+ *
+ * Data-ness is judged by the values actually written, never by the declared
+ * type. Because the caller has explained every mention of the constructor,
+ * no alias can store into the static, so its named writes are all it holds.
+ * A declared type only states what a write MAY store: three's
+ * `@type {?Image} Texture.DEFAULT_IMAGE = null` names a constructor type that
+ * no write realises.
+ */
+export const sourceClassStaticDataUseOf = (checker, flow, reference) => {
+    const access = reference.parent;
+    if ((!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) || access.expression !== reference)
+        return false;
+    const target = flow.targetOf(access);
+    const declaration = target?.declaration;
+    if (!declaration || declaration.getSourceFile().isDeclarationFile)
+        return false;
+    const staticField = ts.isPropertyDeclaration(declaration) && (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Static) !== 0;
+    const expando = (ts.isPropertyAccessExpression(declaration) || ts.isElementAccessExpression(declaration)) &&
+        ts.isBinaryExpression(declaration.parent) &&
+        declaration.parent.left === declaration &&
+        declaration.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
+    if (!staticField && !expando)
+        return false;
+    if (flow.receiverReferencesToDeclaration(declaration).length > 0)
+        return false;
+    const writes = flow.writesToDeclaration(declaration);
+    return (writes.length > 0 &&
+        writes.every((write) => write.slot === 'whole' &&
+            (write.edge === 'class-field-initializer' || write.edge === 'property-assignment') &&
+            write.value !== null &&
+            dataValue(checker.getTypeAtLocation(write.value))));
+};

package/dist/semantics/normalize/flow/source-construction-frames.d.ts

@@ -0,0 +1,12 @@
+import ts from 'typescript';
+import { type SourceClass, type ValueFlowIndex } from './model.js';
+export interface SourceConstructionFrames {
+    /** Runtime classes and source bases whose instance construction work can execute. */
+    readonly receiverOwnersOf: (call: ts.NewExpression) => readonly SourceClass[] | null;
+    /** The explicit source constructor frames entered by this construction or `super()`. */
+    readonly targetsOf: (call: ts.NewExpression | ts.CallExpression) => readonly ts.SignatureDeclaration[] | null;
+}
+/** Construction and constructor execution are different facts: an explicit
+ * derived constructor runs its base body with the arguments at `super()`, not
+ * with the arguments originally passed to `new Derived(...)`. */
+export declare const sourceConstructionFramesOf: (checker: ts.TypeChecker, flow: ValueFlowIndex) => SourceConstructionFrames;

package/dist/semantics/normalize/flow/source-construction-frames.js

@@ -0,0 +1,118 @@
+import ts from 'typescript';
+import { exactSourceConstructionOf, sourceConstructorSelectionsOf } from './member-call-forwarding.js';
+import { isClassSpelledSourceClass } from './model.js';
+const caches = new WeakMap();
+/** Construction and constructor execution are different facts: an explicit
+ * derived constructor runs its base body with the arguments at `super()`, not
+ * with the arguments originally passed to `new Derived(...)`. */
+export const sourceConstructionFramesOf = (checker, flow) => {
+    let cache = caches.get(flow);
+    if (!cache) {
+        cache = { receiverOwners: new WeakMap(), targets: new WeakMap() };
+        caches.set(flow, cache);
+    }
+    const baseSelectionsOf = (owner) => {
+        const clauses = owner.heritageClauses?.filter((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ?? [];
+        if (clauses.length === 0)
+            return [];
+        if (clauses.length !== 1 || clauses[0]?.types.length !== 1)
+            return null;
+        const base = clauses[0].types[0];
+        return base ? sourceConstructorSelectionsOf(checker, flow, base.expression) : null;
+    };
+    const receiverOwnersOf = (call) => {
+        if (cache.receiverOwners.has(call))
+            return cache.receiverOwners.get(call);
+        const construction = exactSourceConstructionOf(checker, flow, call);
+        if (!construction) {
+            cache.receiverOwners.set(call, null);
+            return null;
+        }
+        const owners = new Set();
+        const active = new Set();
+        const include = (selected) => {
+            if (active.has(selected))
+                return false;
+            if (owners.has(selected))
+                return true;
+            owners.add(selected);
+            if (!isClassSpelledSourceClass(selected))
+                return true;
+            active.add(selected);
+            const bases = baseSelectionsOf(selected);
+            const complete = bases !== null && bases.every(include);
+            active.delete(selected);
+            return complete;
+        };
+        const complete = construction.alternatives.every(include);
+        const answer = complete ? [...owners] : null;
+        cache.receiverOwners.set(call, answer);
+        return answer;
+    };
+    const firstExplicitConstructorOf = (selected, active = new Set()) => {
+        if (active.has(selected))
+            return null;
+        if (!isClassSpelledSourceClass(selected))
+            return [selected];
+        const constructors = selected.members.filter(ts.isConstructorDeclaration);
+        const implementation = constructors.find((constructor) => constructor.body !== undefined);
+        if (implementation)
+            return [implementation];
+        if (constructors.length > 0)
+            return null;
+        active.add(selected);
+        const bases = baseSelectionsOf(selected);
+        if (bases === null) {
+            active.delete(selected);
+            return null;
+        }
+        const targets = new Set();
+        for (const base of bases) {
+            const inherited = firstExplicitConstructorOf(base, active);
+            if (inherited === null) {
+                active.delete(selected);
+                return null;
+            }
+            inherited.forEach((target) => targets.add(target));
+        }
+        active.delete(selected);
+        return [...targets];
+    };
+    const targetsOf = (call) => {
+        if (cache.targets.has(call))
+            return cache.targets.get(call);
+        let selections;
+        if (ts.isNewExpression(call)) {
+            const construction = exactSourceConstructionOf(checker, flow, call);
+            selections = construction?.alternatives ?? null;
+        }
+        else {
+            const site = flow.callSiteOf(call);
+            const dispatch = site?.operands.dispatch;
+            if (call.expression.kind !== ts.SyntaxKind.SuperKeyword || dispatch?.kind !== 'super-constructor' || !dispatch.home) {
+                cache.targets.set(call, null);
+                return null;
+            }
+            selections = baseSelectionsOf(dispatch.home);
+            if (selections?.length === 0)
+                selections = null;
+        }
+        if (selections === null) {
+            cache.targets.set(call, null);
+            return null;
+        }
+        const targets = new Set();
+        for (const selected of selections) {
+            const found = firstExplicitConstructorOf(selected);
+            if (found === null) {
+                cache.targets.set(call, null);
+                return null;
+            }
+            found.forEach((target) => targets.add(target));
+        }
+        const answer = [...targets];
+        cache.targets.set(call, answer);
+        return answer;
+    };
+    return { receiverOwnersOf, targetsOf };
+};

package/dist/semantics/normalize/flow/source-invocation-frame-layout.d.ts

@@ -0,0 +1,34 @@
+import ts from 'typescript';
+import type { FlowInvocationOperands, ReceiverReference, ValueFlowIndex } from './model.js';
+import { type SourceInvocationReceiverFact } from './source-invocation-receiver.js';
+export type SourceInvocationParameterSlot = {
+    readonly kind: 'single';
+    readonly parameter: ts.ParameterDeclaration;
+    readonly actual: ts.Expression | null;
+    /** Evaluated only when the actual value is undefined, including omission. */
+    readonly defaultValue: ts.Expression | null;
+    readonly defaultActivation: 'never' | 'always' | 'maybe';
+} | {
+    readonly kind: 'rest';
+    readonly parameter: ts.ParameterDeclaration;
+    readonly actuals: readonly ts.Expression[];
+};
+/** Immutable source frame inventory. Value and effect queries consume these
+ * positions; neither the caller's checker signature nor its inferred type can
+ * change the executable frame. */
+export interface SourceInvocationFrameLayout {
+    readonly call: ts.CallExpression | ts.NewExpression;
+    readonly body: ts.SignatureDeclaration;
+    readonly operands: FlowInvocationOperands;
+    readonly receiver: SourceInvocationReceiverFact;
+    readonly receiverUses: readonly ReceiverReference[];
+    readonly parameters: readonly ts.ParameterDeclaration[];
+    readonly arguments: {
+        readonly kind: 'positional';
+        readonly slots: readonly SourceInvocationParameterSlot[];
+    } | {
+        readonly kind: 'spread';
+        readonly values: readonly ts.Expression[];
+    };
+}
+export declare const sourceInvocationFrameLayoutOf: (flow: ValueFlowIndex, call: ts.CallExpression | ts.NewExpression, body: ts.SignatureDeclaration) => SourceInvocationFrameLayout | null;

package/dist/semantics/normalize/flow/source-invocation-frame-layout.js

@@ -0,0 +1,78 @@
+import ts from 'typescript';
+import { unwrapErasedExpression } from '../producers/erasure.js';
+import { runtimeParametersOf } from './targets.js';
+import { sourceInvocationReceiverOf } from './source-invocation-receiver.js';
+const layouts = new WeakMap();
+const unwrapped = (expression) => {
+    let current = unwrapErasedExpression(expression);
+    while (ts.isParenthesizedExpression(current))
+        current = unwrapErasedExpression(current.expression);
+    return current;
+};
+const isBoundUndefined = (flow, expression) => {
+    const value = unwrapped(expression);
+    if (!ts.isIdentifier(value) || value.text !== 'undefined')
+        return false;
+    const declaration = flow.targetOf(value)?.declaration;
+    return !declaration || declaration.getSourceFile().hasNoDefaultLib;
+};
+const isDefinitelyDefined = (expression) => {
+    const value = unwrapped(expression);
+    return (ts.isLiteralExpression(value) ||
+        ts.isNoSubstitutionTemplateLiteral(value) ||
+        value.kind === ts.SyntaxKind.NullKeyword ||
+        value.kind === ts.SyntaxKind.TrueKeyword ||
+        value.kind === ts.SyntaxKind.FalseKeyword ||
+        ts.isObjectLiteralExpression(value) ||
+        ts.isArrayLiteralExpression(value) ||
+        ts.isFunctionExpression(value) ||
+        ts.isArrowFunction(value) ||
+        ts.isClassExpression(value) ||
+        ts.isNewExpression(value));
+};
+const defaultActivationOf = (flow, actual, defaultValue) => {
+    if (!defaultValue)
+        return 'never';
+    if (actual === null || ts.isVoidExpression(unwrapped(actual)) || isBoundUndefined(flow, actual))
+        return 'always';
+    if (isDefinitelyDefined(actual))
+        return 'never';
+    return 'maybe';
+};
+export const sourceInvocationFrameLayoutOf = (flow, call, body) => {
+    let calls = layouts.get(flow);
+    if (!calls)
+        layouts.set(flow, (calls = new WeakMap()));
+    let bodies = calls.get(call);
+    if (!bodies)
+        calls.set(call, (bodies = new WeakMap()));
+    if (bodies.has(body))
+        return bodies.get(body);
+    const site = flow.callSiteOf(call);
+    if (!site || !flow.callableBodyIsIndexed(body)) {
+        bodies.set(body, null);
+        return null;
+    }
+    const parameters = runtimeParametersOf(body);
+    const args = site.operands.args;
+    const slots = parameters.map((parameter, index) => parameter.dotDotDotToken
+        ? { kind: 'rest', parameter, actuals: args.slice(index) }
+        : {
+            kind: 'single',
+            parameter,
+            actual: args[index] ?? null,
+            defaultValue: parameter.initializer ?? null,
+            defaultActivation: defaultActivationOf(flow, args[index] ?? null, parameter.initializer ?? null)
+        });
+    const layout = {
+        call,
+        body,
+        operands: site.operands,
+        receiver: sourceInvocationReceiverOf(flow, call, body),
+        receiverUses: ts.isArrowFunction(body) ? [] : flow.receiverReferencesToDeclaration(body),
+        parameters,
+        arguments: args.some(ts.isSpreadElement) ? { kind: 'spread', values: args } : { kind: 'positional', slots }
+    };
+    bodies.set(body, layout);
+    return layout;
+};

package/dist/semantics/normalize/flow/source-invocation-receiver.d.ts

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+export type SourceInvocationReceiverFact = {
+    readonly kind: 'expression';
+    readonly expression: ts.Expression;
+    readonly conversion: 'identity' | 'sloppy-this';
+} | {
+    readonly kind: 'undefined';
+    readonly reason: 'strict-direct' | 'strict-missing-this-argument';
+} | {
+    readonly kind: 'global-object';
+    readonly reason: 'sloppy-direct' | 'sloppy-missing-this-argument' | 'sloppy-nullish-this-argument';
+    readonly expression?: ts.Expression;
+} | {
+    readonly kind: 'lexical';
+    readonly source: 'arrow';
+    readonly owner: ts.Node | null;
+} | {
+    readonly kind: 'lexical';
+    readonly source: 'super-member';
+    readonly owner: ts.Node;
+    readonly static: boolean;
+} | {
+    readonly kind: 'lexical';
+    readonly source: 'super-constructor';
+    readonly owner: ts.Node;
+} | {
+    readonly kind: 'constructed';
+    readonly call: ts.NewExpression;
+} | {
+    readonly kind: 'unsupported';
+    readonly reason: 'unindexed-call' | 'unresolved-super-home' | 'nullish-member-base';
+};
+/** Project only JavaScript's receiver binding rules for one already-admitted
+ * invocation/body pair. It deliberately states coercion; proving the source
+ * value is a native object belongs to the consumer's existing graph proof. */
+export declare const sourceInvocationReceiverOf: (flow: ValueFlowIndex, call: ts.CallExpression | ts.NewExpression, body: ts.SignatureDeclaration) => SourceInvocationReceiverFact;

package/dist/semantics/normalize/flow/source-invocation-receiver.js

@@ -0,0 +1,95 @@
+import ts from 'typescript';
+import { isStrictContext } from '../producers/shared.js';
+import { unwrapErasedExpression } from '../producers/erasure.js';
+const unwrapped = (expression) => {
+    let current = unwrapErasedExpression(expression);
+    while (ts.isParenthesizedExpression(current))
+        current = unwrapErasedExpression(current.expression);
+    return current;
+};
+const definitelyNullish = (flow, expression) => {
+    const value = unwrapped(expression);
+    if (value.kind === ts.SyntaxKind.NullKeyword || ts.isVoidExpression(value))
+        return true;
+    if (!ts.isIdentifier(value) || value.text !== 'undefined')
+        return false;
+    const declaration = flow.targetOf(value)?.declaration;
+    return !declaration || declaration.getSourceFile().hasNoDefaultLib;
+};
+const lexicalOwnerOf = (flow, body) => {
+    let indexedOwner = null;
+    const findIndexedReference = (node) => {
+        if (indexedOwner)
+            return;
+        if (node !== body && (ts.isClassLike(node) || (ts.isFunctionLike(node) && !ts.isArrowFunction(node))))
+            return;
+        if (node.kind === ts.SyntaxKind.ThisKeyword || node.kind === ts.SyntaxKind.SuperKeyword) {
+            indexedOwner = flow.receiverOwnerOf(node);
+            if (indexedOwner)
+                return;
+        }
+        ts.forEachChild(node, findIndexedReference);
+    };
+    findIndexedReference(body.body);
+    if (indexedOwner)
+        return indexedOwner;
+    let branch = body;
+    for (let current = body.parent; current; branch = current, current = current.parent) {
+        if ((ts.isMethodDeclaration(current) ||
+            ts.isGetAccessorDeclaration(current) ||
+            ts.isSetAccessorDeclaration(current) ||
+            ts.isPropertyDeclaration(current)) &&
+            current.name === branch)
+            continue;
+        if (ts.isArrowFunction(current))
+            continue;
+        if (ts.isFunctionLike(current) || ts.isPropertyDeclaration(current) || ts.isClassStaticBlockDeclaration(current))
+            return current;
+        if (ts.isSourceFile(current))
+            return current;
+    }
+    return null;
+};
+/** Project only JavaScript's receiver binding rules for one already-admitted
+ * invocation/body pair. It deliberately states coercion; proving the source
+ * value is a native object belongs to the consumer's existing graph proof. */
+export const sourceInvocationReceiverOf = (flow, call, body) => {
+    const site = flow.callSiteOf(call);
+    if (!site)
+        return { kind: 'unsupported', reason: 'unindexed-call' };
+    const operands = site.operands;
+    if (ts.isNewExpression(call))
+        return { kind: 'constructed', call };
+    if (operands.dispatch.kind === 'super-constructor') {
+        return operands.dispatch.home
+            ? { kind: 'lexical', source: 'super-constructor', owner: operands.dispatch.home }
+            : { kind: 'unsupported', reason: 'unresolved-super-home' };
+    }
+    if (ts.isArrowFunction(body))
+        return { kind: 'lexical', source: 'arrow', owner: lexicalOwnerOf(flow, body) };
+    const strict = isStrictContext(body, flow.buildIsStrict);
+    if (operands.explicitThis) {
+        const receiver = operands.receiver;
+        if (receiver === null)
+            return strict
+                ? { kind: 'undefined', reason: 'strict-missing-this-argument' }
+                : { kind: 'global-object', reason: 'sloppy-missing-this-argument' };
+        if (definitelyNullish(flow, receiver) && !strict)
+            return { kind: 'global-object', reason: 'sloppy-nullish-this-argument', expression: receiver };
+        return { kind: 'expression', expression: receiver, conversion: strict ? 'identity' : 'sloppy-this' };
+    }
+    if (operands.dispatch.kind === 'lexical-super') {
+        return operands.dispatch.home
+            ? { kind: 'lexical', source: 'super-member', owner: operands.dispatch.home, static: operands.dispatch.static }
+            : { kind: 'unsupported', reason: 'unresolved-super-home' };
+    }
+    if (operands.dispatch.kind === 'member') {
+        const receiver = operands.receiver;
+        if (receiver === null)
+            return { kind: 'unsupported', reason: 'unindexed-call' };
+        if (definitelyNullish(flow, receiver))
+            return { kind: 'unsupported', reason: 'nullish-member-base' };
+        return { kind: 'expression', expression: receiver, conversion: strict ? 'identity' : 'sloppy-this' };
+    }
+    return strict ? { kind: 'undefined', reason: 'strict-direct' } : { kind: 'global-object', reason: 'sloppy-direct' };
+};

package/dist/semantics/normalize/flow/source-prototype-method-identity.d.ts

@@ -0,0 +1,23 @@
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+/**
+ * A declaration that puts a source method in a class's non-static prototype
+ * slot -- the only member shape whose value is a body this compiler has walked
+ * and whose slot the class itself, rather than a constructor assignment,
+ * created.
+ *
+ * Exported because two proofs need the same admission and a second spelling of
+ * it would be two authorities on what a method slot is: the identity
+ * observation below, and `sourceClassCallableMemberPlanOf`'s question of which
+ * bodies a key on this family resolves to.
+ */
+export declare const isSourceInstanceMethod: (declaration: ts.Declaration) => boolean;
+/** A source prototype METHOD can be observed for strict identity without
+ * handing out the prototype or executing a receiver-bearing callback. The
+ * caller still validates every constructor/prototype reference, including
+ * the declaring base classes: this helper alone does not prove descriptors
+ * immutable. Aliases are accepted only when all their graph-visible uses are
+ * identity observations. Module import/export references use the same closed
+ * source graph inventory as their owning constructor.
+ */
+export declare const sourcePrototypeMethodIdentityUseOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, reference: ts.Expression, instance: ts.InterfaceType) => boolean;

package/dist/semantics/normalize/flow/source-prototype-method-identity.js

@@ -0,0 +1,81 @@
+import ts from 'typescript';
+import { outermostErasureOf } from '../producers/erasure.js';
+import { isTypePositionReference, namespaceMemberDeclarationOf } from './targets.js';
+/**
+ * A declaration that puts a source method in a class's non-static prototype
+ * slot -- the only member shape whose value is a body this compiler has walked
+ * and whose slot the class itself, rather than a constructor assignment,
+ * created.
+ *
+ * Exported because two proofs need the same admission and a second spelling of
+ * it would be two authorities on what a method slot is: the identity
+ * observation below, and `sourceClassCallableMemberPlanOf`'s question of which
+ * bodies a key on this family resolves to.
+ */
+export const isSourceInstanceMethod = (declaration) => ts.isMethodDeclaration(declaration) &&
+    declaration.body !== undefined &&
+    !declaration.getSourceFile().isDeclarationFile &&
+    (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Static) === 0;
+const keyOf = (access) => ts.isPropertyAccessExpression(access)
+    ? access.name.text
+    : ts.isStringLiteralLike(access.argumentExpression)
+        ? access.argumentExpression.text
+        : null;
+/** A source prototype METHOD can be observed for strict identity without
+ * handing out the prototype or executing a receiver-bearing callback. The
+ * caller still validates every constructor/prototype reference, including
+ * the declaring base classes: this helper alone does not prove descriptors
+ * immutable. Aliases are accepted only when all their graph-visible uses are
+ * identity observations. Module import/export references use the same closed
+ * source graph inventory as their owning constructor.
+ */
+export const sourcePrototypeMethodIdentityUseOf = (checker, flow, reference, instance) => {
+    const prototype = reference.parent;
+    if ((!ts.isPropertyAccessExpression(prototype) && !ts.isElementAccessExpression(prototype)) ||
+        prototype.expression !== reference ||
+        keyOf(prototype) !== 'prototype')
+        return false;
+    const selected = outermostErasureOf(prototype);
+    const access = selected.parent;
+    if ((!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) || access.expression !== selected)
+        return false;
+    const key = keyOf(access);
+    const method = key === null ? undefined : checker.getPropertyOfType(instance, key);
+    if (!method?.declarations?.length || !method.declarations.every(isSourceInstanceMethod))
+        return false;
+    const seen = new Set();
+    const observed = (expression) => {
+        if (seen.has(expression))
+            return true;
+        seen.add(expression);
+        const current = outermostErasureOf(expression);
+        const parent = current.parent;
+        if (!parent)
+            return false;
+        if (ts.isBinaryExpression(parent) &&
+            (parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+                parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken))
+            return true;
+        if (!ts.isVariableDeclaration(parent) || parent.initializer !== current || !ts.isIdentifier(parent.name))
+            return false;
+        if ((parent.parent.flags & ts.NodeFlags.Const) === 0)
+            return false;
+        const writes = flow.writesToDeclaration(parent).filter((write) => write.slot === 'whole');
+        if (writes.some((write) => write.edge !== 'declaration-initializer' || write.value !== parent.initializer))
+            return false;
+        return flow.referencesToDeclaration(parent).every((mention) => {
+            if (mention === parent.name || isTypePositionReference(mention))
+                return true;
+            const use = mention.parent;
+            if (ts.isImportSpecifier(use) || ts.isExportSpecifier(use))
+                return true;
+            const selected = ((ts.isPropertyAccessExpression(use) && use.name === mention) ||
+                (ts.isElementAccessExpression(use) && use.argumentExpression === mention)) &&
+                namespaceMemberDeclarationOf(checker, use) === parent
+                ? use
+                : mention;
+            return observed(selected);
+        });
+    };
+    return observed(access);
+};

package/dist/semantics/normalize/flow/source-record-data.d.ts

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+import { callableCompletionValuesOf } from './callable-completions.js';
+import { type OriginAuthority } from './origin-authority.js';
+import { type IntrinsicProtocolRequirement } from '../deferred-intrinsic-protocols.js';
+export interface SourceRecordDataWritePlan {
+    /** Every allocation whose descriptors and publications the caller must close. */
+    readonly roots: readonly ts.ObjectLiteralExpression[];
+    /** Missing own slots additionally depend on the intrinsic Object prototype. */
+    readonly needsDefaultPrototype: boolean;
+    /** Deferred protocol obligations discovered while following cached origins. */
+    readonly requirements: readonly IntrinsicProtocolRequirement[];
+}
+/** @semanticCategory generic-primitive */
+export type { SourceRecordOriginAuthority } from './origin-authority.js';
+/** A source callable a record slot can hold, independent of completion support. */
+export type RecordMethodTarget = ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction;
+export { callableCompletionValuesOf };
+export declare const recordMethodCallTargetsOf: (flow: ValueFlowIndex, call: ts.CallExpression, authority: OriginAuthority) => readonly RecordMethodTarget[] | null;
+/** Every value `record.key( ... )` can return: the completions of every
+ * callable `recordMethodCallTargetsOf` names, or null when any target's
+ * normal completion is unsupported. Target admission remains useful when
+ * this separate result query refuses. */
+export declare const recordMethodCallResultsOf: (flow: ValueFlowIndex, call: ts.CallExpression, authority: OriginAuthority) => readonly ts.Expression[] | null;
+export declare const sourceRecordDataWritePlanOf: (flow: ValueFlowIndex, receiver: ts.Expression, key: string, authority: OriginAuthority) => SourceRecordDataWritePlan | null;
+/** The stored values of a closed own record slot. The allocation, descriptor,
+ * alias and replacement checks are shared with nested record-origin reads;
+ * a consumer must still establish the provenance of each returned value. */
+export declare const sourceRecordSlotValuesOf: (flow: ValueFlowIndex, access: ts.PropertyAccessExpression | ts.ElementAccessExpression, authority: OriginAuthority) => readonly ts.Expression[] | null;