@geastack/compiler 1.0.15

package/dist/semantics/normalize/flow/record-alias-closure.js

@@ -0,0 +1,298 @@
+import ts from 'typescript';
+import { outermostErasureOf, unwrapErasedExpression } from '../producers/erasure.js';
+import { constructionYieldsCompletionOf } from './callable-completions.js';
+import { inProgramImportReferencesOf } from './export-importers.js';
+import { isModuleExportedDeclaration, isTypePositionReference, resolveFlowSymbolAlias, returnOwnerOf } from './targets.js';
+/** The static key an object-literal entry is published under, or null when it has none. */
+export const objectLiteralEntryKeyOf = (name) => {
+    if (ts.isIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name))
+        return name.text;
+    if (!ts.isComputedPropertyName(name))
+        return null;
+    const inner = unwrapErasedExpression(name.expression);
+    return ts.isStringLiteralLike(inner) || ts.isNumericLiteral(inner) ? inner.text : null;
+};
+/** A function declaration whose binding is reassigned names different functions over time. */
+const bindingWritten = (flow, declaration) => flow
+    .writesToDeclaration(declaration)
+    .some((write) => write.slot === 'whole' &&
+    (write.edge === 'identifier-assignment' || write.edge === 'compound-assignment' || write.edge === 'logical-assignment'));
+/** Whether `node` (already at its outermost erasure) is written rather than read. */
+const isWriteTarget = (node) => {
+    const parent = node.parent;
+    if (ts.isBinaryExpression(parent) &&
+        parent.left === node &&
+        parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+        parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+        return true;
+    if (ts.isDeleteExpression(parent))
+        return true;
+    if ((ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) &&
+        (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken))
+        return true;
+    if ((ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer === node)
+        return true;
+    // A destructuring assignment pattern: `[ r.get ] = xs`, `({ a: r.get } = o)`.
+    let pattern = node;
+    for (;;) {
+        const container = pattern.parent;
+        if (ts.isArrayLiteralExpression(container) ||
+            ts.isObjectLiteralExpression(container) ||
+            ts.isSpreadElement(container) ||
+            ts.isSpreadAssignment(container) ||
+            ts.isParenthesizedExpression(container) ||
+            ts.isShorthandPropertyAssignment(container) ||
+            (ts.isPropertyAssignment(container) && container.initializer === pattern)) {
+            pattern = container;
+            continue;
+        }
+        break;
+    }
+    if (pattern === node)
+        return false;
+    const holder = pattern.parent;
+    return ((ts.isBinaryExpression(holder) && holder.left === pattern && holder.operatorToken.kind === ts.SyntaxKind.EqualsToken) ||
+        ((ts.isForOfStatement(holder) || ts.isForInStatement(holder)) && holder.initializer === pattern));
+};
+const isNullish = (expression) => {
+    const value = unwrapErasedExpression(expression);
+    return value.kind === ts.SyntaxKind.NullKeyword || (ts.isIdentifier(value) && value.text === 'undefined');
+};
+const proofs = {
+    slots: new WeakMap(),
+    receiver: new WeakMap()
+};
+const memoized = (checker, flow, root, proof) => {
+    let memo = proofs[proof].get(flow);
+    if (!memo)
+        proofs[proof].set(flow, (memo = new Map()));
+    const held = memo.get(root);
+    if (held !== undefined)
+        return held;
+    const answer = proveAliasesClosed(checker, flow, root, proof);
+    memo.set(root, answer);
+    return answer;
+};
+export const recordAllocationAliasesClosed = (checker, flow, root) => memoized(checker, flow, root, 'slots');
+/**
+ * Whether `this`, in a function this literal was written holding, can only
+ * ever be one of the literal's own allocations.
+ *
+ * A function written in place in a literal is reachable only through the
+ * literal's slot. If no alias of the literal hands that slot's function out as
+ * a value, and every alias reaches only uses this proof enumerates, then every
+ * call of the function is `alias.key( ... )`, and its receiver is the literal.
+ * Three's `ColorManagement` is such a record: `convert` reads `this.enabled`,
+ * and the checker names the literal's `enabled: true` for it -- a name a second
+ * literal with a getter under that key would satisfy just as well, which is why
+ * the checker's answer alone is not evidence.
+ *
+ * The walk is the slot proof's, with three differences. A store into a data
+ * slot is admitted: it keeps the slot data and hands the record to no one. A
+ * call of a slot whose function reads `this` follows that function's every
+ * `this` as one more alias, where the slot proof refused it. And an exported
+ * cell is followed into every importer (`inProgramImportReferencesOf`). A read
+ * of a `this`-reading function as a value still refuses: that is the function
+ * leaving the record.
+ */
+export const recordLiteralReceiverClosed = (checker, flow, root) => memoized(checker, flow, root, 'receiver');
+const proveAliasesClosed = (checker, flow, root, proof) => {
+    const receiver = proof === 'receiver';
+    const slots = new Map();
+    const callableOf = (property) => {
+        if (ts.isMethodDeclaration(property))
+            return property;
+        const value = ts.isPropertyAssignment(property) ? unwrapErasedExpression(property.initializer) : null;
+        if (value && (ts.isFunctionExpression(value) || ts.isArrowFunction(value)))
+            return value;
+        const symbol = ts.isShorthandPropertyAssignment(property)
+            ? checker.getShorthandAssignmentValueSymbol(property)
+            : value && ts.isIdentifier(value)
+                ? checker.getSymbolAtLocation(value)
+                : undefined;
+        const declaration = resolveFlowSymbolAlias(checker, symbol)?.valueDeclaration;
+        return declaration && ts.isFunctionDeclaration(declaration) && !bindingWritten(flow, declaration) ? declaration : null;
+    };
+    for (const property of root.properties) {
+        if (ts.isSpreadAssignment(property) || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property))
+            return false;
+        const key = objectLiteralEntryKeyOf(property.name);
+        if (key === null)
+            return false;
+        if (key === '__proto__') {
+            // Only a null prototype is closed; any other prototype supplies inherited slots.
+            if (!ts.isPropertyAssignment(property) || !isNullish(property.initializer))
+                return false;
+            continue;
+        }
+        slots.set(key, callableOf(property));
+    }
+    const seen = new Set();
+    const readsReceiver = (callable) => !ts.isArrowFunction(callable) && flow.receiverReferencesToDeclaration(callable).length > 0;
+    /** An assignment or increment of a slot -- not a `delete`, and not a destructuring or loop target. */
+    const dataStore = (positioned) => {
+        const parent = positioned.parent;
+        return ((ts.isBinaryExpression(parent) && parent.left === positioned) ||
+            ts.isPrefixUnaryExpression(parent) ||
+            ts.isPostfixUnaryExpression(parent));
+    };
+    /** A named slot of an alias: a read is inert; a call runs the slot's callable with the record as `this`. */
+    const member = (access, key) => {
+        if (key === null || !slots.has(key))
+            return false;
+        const positioned = outermostErasureOf(access);
+        const callable = slots.get(key) ?? null;
+        if (isWriteTarget(positioned))
+            return receiver && callable === null && dataStore(positioned);
+        const parent = positioned.parent;
+        const called = (ts.isCallExpression(parent) && parent.expression === positioned) ||
+            (ts.isTaggedTemplateExpression(parent) && parent.tag === positioned);
+        if (!called)
+            return !receiver || callable === null || !readsReceiver(callable);
+        if (callable === null)
+            return false;
+        if (!readsReceiver(callable))
+            return true;
+        return receiver && flow.receiverReferencesToDeclaration(callable).every(value);
+    };
+    /** A cell holding the record: every mention of it must be followed. */
+    const cell = (declaration) => {
+        if (seen.has(declaration))
+            return true;
+        seen.add(declaration);
+        if (!ts.isIdentifier(declaration.name))
+            return false;
+        const exported = ts.isVariableDeclaration(declaration) &&
+            isModuleExportedDeclaration(checker, declaration, checker.getSymbolAtLocation(declaration.name) ?? null);
+        if (exported && !receiver)
+            return false;
+        const references = new Set(flow.referencesToDeclaration(declaration));
+        if (exported) {
+            const imported = inProgramImportReferencesOf(checker, flow, declaration);
+            if (imported === null)
+                return false;
+            for (const reference of imported)
+                references.add(reference);
+        }
+        for (const reference of references) {
+            if (reference === declaration.name)
+                continue;
+            if (ts.isIdentifier(reference) && (isTypePositionReference(reference) || ts.isTypeQueryNode(reference.parent)))
+                continue;
+            // The binding itself, not a use of its value: every importer's mention
+            // is already among the references above.
+            if (exported &&
+                (ts.isImportSpecifier(reference.parent) || ts.isImportClause(reference.parent) || ts.isExportSpecifier(reference.parent)))
+                continue;
+            if (ts.isExportSpecifier(reference.parent) || ts.isShorthandPropertyAssignment(reference.parent))
+                return false;
+            const positioned = outermostErasureOf(reference);
+            const parent = positioned.parent;
+            // Overwritten: the cell now holds the assigned value, not this record.
+            if (ts.isBinaryExpression(parent) && parent.left === positioned && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+                continue;
+            if (isWriteTarget(positioned) || !value(reference))
+                return false;
+        }
+        return true;
+    };
+    const assigned = (target) => {
+        const named = unwrapErasedExpression(target);
+        if (!ts.isIdentifier(named))
+            return false;
+        const declaration = flow.targetOf(named)?.declaration;
+        return !!declaration && (ts.isVariableDeclaration(declaration) || ts.isParameter(declaration)) && cell(declaration);
+    };
+    /** Every call of a factory whose `return` carries the record yields it. */
+    const callers = (factory) => {
+        if (seen.has(factory))
+            return true;
+        seen.add(factory);
+        if (!factory.name || factory.asteriskToken || factory.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword))
+            return false;
+        const references = new Set(flow.referencesToDeclaration(factory));
+        if (isModuleExportedDeclaration(checker, factory, checker.getSymbolAtLocation(factory.name) ?? null)) {
+            const imported = inProgramImportReferencesOf(checker, flow, factory);
+            if (imported === null)
+                return false;
+            for (const reference of imported)
+                references.add(reference);
+        }
+        for (const reference of references) {
+            if (reference === factory.name)
+                continue;
+            const parent = reference.parent;
+            if (ts.isIdentifier(reference) && (isTypePositionReference(reference) || ts.isTypeQueryNode(parent)))
+                continue;
+            if (ts.isImportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent) || ts.isExportSpecifier(parent))
+                continue;
+            if (ts.isExportAssignment(parent) && !parent.isExportEquals)
+                continue;
+            // `ns.factory` is indexed under both the access and its name.
+            const site = ts.isPropertyAccessExpression(parent) && parent.name === reference ? parent : reference;
+            const positioned = outermostErasureOf(site);
+            const call = positioned.parent;
+            if ((ts.isCallExpression(call) || ts.isNewExpression(call)) && call.expression === positioned) {
+                // Under `new`, a non-object completion yields `this` instead.
+                if (ts.isNewExpression(call) && !constructionYieldsCompletionOf(flow, factory))
+                    return false;
+                if (!value(call))
+                    return false;
+                continue;
+            }
+            return false;
+        }
+        return true;
+    };
+    const value = (expression) => {
+        if (seen.has(expression))
+            return true;
+        seen.add(expression);
+        const parent = expression.parent;
+        if (ts.isParenthesizedExpression(parent) ||
+            ts.isAsExpression(parent) ||
+            ts.isSatisfiesExpression(parent) ||
+            ts.isNonNullExpression(parent) ||
+            ts.isTypeAssertionExpression(parent))
+            return value(parent);
+        if (ts.isPropertyAccessExpression(parent) && parent.expression === expression)
+            return member(parent, parent.name.text);
+        if (ts.isElementAccessExpression(parent) && parent.expression === expression) {
+            const argument = unwrapErasedExpression(parent.argumentExpression);
+            return member(parent, ts.isStringLiteralLike(argument) || ts.isNumericLiteral(argument) ? argument.text : null);
+        }
+        if (ts.isBinaryExpression(parent)) {
+            const operator = parent.operatorToken.kind;
+            if (operator === ts.SyntaxKind.EqualsEqualsEqualsToken || operator === ts.SyntaxKind.ExclamationEqualsEqualsToken)
+                return true;
+            // Loose equality with anything but null/undefined runs ToPrimitive on the record.
+            if (operator === ts.SyntaxKind.EqualsEqualsToken || operator === ts.SyntaxKind.ExclamationEqualsToken)
+                return isNullish(parent.left === expression ? parent.right : parent.left);
+            if (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
+                operator === ts.SyntaxKind.BarBarToken ||
+                operator === ts.SyntaxKind.QuestionQuestionToken)
+                return value(parent);
+            if (operator === ts.SyntaxKind.CommaToken)
+                return parent.left === expression || value(parent);
+            if (operator === ts.SyntaxKind.EqualsToken && parent.right === expression)
+                return assigned(parent.left) && (ts.isExpressionStatement(parent.parent) || value(parent));
+            return false;
+        }
+        if (ts.isConditionalExpression(parent))
+            return parent.condition === expression || value(parent);
+        if (ts.isPrefixUnaryExpression(parent))
+            return parent.operator === ts.SyntaxKind.ExclamationToken;
+        if (ts.isTypeOfExpression(parent) || ts.isVoidExpression(parent) || ts.isExpressionStatement(parent))
+            return true;
+        if ((ts.isIfStatement(parent) || ts.isWhileStatement(parent) || ts.isDoStatement(parent)) && parent.expression === expression)
+            return true;
+        if (ts.isVariableDeclaration(parent) && parent.initializer === expression)
+            return cell(parent);
+        if (ts.isReturnStatement(parent)) {
+            const owner = returnOwnerOf(parent);
+            return !!owner && ts.isFunctionDeclaration(owner) && callers(owner);
+        }
+        return false;
+    };
+    return value(root);
+};

package/dist/semantics/normalize/flow/seeded-origins.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Allocation provenance solved one strongly connected component at a time.
+ *
+ * An origin graph is cyclic wherever storage is reused. Three's
+ * `WebGLRenderList.getNextRenderItem` reads `renderItems[ renderItemsIndex ]`
+ * into `renderItem`, and on a miss stores a fresh literal back into
+ * `renderItems` through that same `renderItem` -- so the element read's
+ * origins include the very cell being proven. A depth-first proof that treats
+ * a node still being visited as false refuses that pool outright; a plain
+ * greatest fixpoint accepts it, but then an origin-only cycle (`a = b; b = a`,
+ * which never holds any allocation at all) borrows the literal of a sibling
+ * conditional branch and "proves" a value set it never had.
+ *
+ * The component is the unit that decides. A cycle is admitted exactly when
+ * the component itself, or a proven component it depends on, contains a real
+ * allocation; an unseeded cycle stays refused. A node that can only ever hold
+ * `null`/`undefined` is vacuous: it contributes no allocation and refuses
+ * nothing, so a reuse pool initialised to `null` still closes on the literal
+ * that fills it.
+ */
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+export type SeededOriginVerdict = 'refused' | 'vacuous' | 'allocated';
+/**
+ * `null`, the global `undefined`, or `void x`: an origin that holds no object.
+ * Three's renderer starts `let currentRenderList = null` and `let _opaqueSort
+ * = null`; neither empty slot can be a receiver or a callee, so it widens no
+ * value set -- but it must not count as the allocation a set needs either. A
+ * local binding that shadows `undefined` has a declaration and is an ordinary
+ * cell instead.
+ */
+export declare const isVacuousOrigin: (flow: ValueFlowIndex, expression: ts.Expression) => boolean;
+/** One provenance node as its domain expands it. */
+export interface SeededOriginNode<K> {
+    /** This node IS an allocation the domain accepts as a value-set root. */
+    readonly seed: boolean;
+    /** False when the node's value set cannot be enumerated at all. */
+    readonly admitted: boolean;
+    /** Every node whose values this node can hold. */
+    readonly dependencies: readonly K[];
+}
+export declare const seededOriginSolvers: () => number;
+export declare const seededOriginSolver: <K>(expand: (key: K) => SeededOriginNode<K>) => ((key: K) => SeededOriginVerdict);

package/dist/semantics/normalize/flow/seeded-origins.js

@@ -0,0 +1,54 @@
+/**
+ * Allocation provenance solved one strongly connected component at a time.
+ *
+ * An origin graph is cyclic wherever storage is reused. Three's
+ * `WebGLRenderList.getNextRenderItem` reads `renderItems[ renderItemsIndex ]`
+ * into `renderItem`, and on a miss stores a fresh literal back into
+ * `renderItems` through that same `renderItem` -- so the element read's
+ * origins include the very cell being proven. A depth-first proof that treats
+ * a node still being visited as false refuses that pool outright; a plain
+ * greatest fixpoint accepts it, but then an origin-only cycle (`a = b; b = a`,
+ * which never holds any allocation at all) borrows the literal of a sibling
+ * conditional branch and "proves" a value set it never had.
+ *
+ * The component is the unit that decides. A cycle is admitted exactly when
+ * the component itself, or a proven component it depends on, contains a real
+ * allocation; an unseeded cycle stays refused. A node that can only ever hold
+ * `null`/`undefined` is vacuous: it contributes no allocation and refuses
+ * nothing, so a reuse pool initialised to `null` still closes on the literal
+ * that fills it.
+ */
+import ts from 'typescript';
+import { dependencyComponentSolver } from './component-solver.js';
+/**
+ * `null`, the global `undefined`, or `void x`: an origin that holds no object.
+ * Three's renderer starts `let currentRenderList = null` and `let _opaqueSort
+ * = null`; neither empty slot can be a receiver or a callee, so it widens no
+ * value set -- but it must not count as the allocation a set needs either. A
+ * local binding that shadows `undefined` has a declaration and is an ordinary
+ * cell instead.
+ */
+export const isVacuousOrigin = (flow, expression) => expression.kind === ts.SyntaxKind.NullKeyword ||
+    ts.isVoidExpression(expression) ||
+    (ts.isIdentifier(expression) && expression.text === 'undefined' && !flow.targetOf(expression)?.declaration);
+/**
+ * A memoized verdict function over a lazily expanded origin graph. `expand`
+ * runs once per reachable key and may record domain facts (roots, stored
+ * values) as it goes: every expanded key is reachable from a queried root, and
+ * a refusal anywhere on a path refuses every node above it, so an `allocated`
+ * root certifies everything expanded on its behalf.
+ */
+/** How many origin solvers this process has built; `GEA_PROOF_STATS` prints it. */
+let solversBuilt = 0;
+export const seededOriginSolvers = () => solversBuilt;
+export const seededOriginSolver = (expand) => {
+    solversBuilt++;
+    const solve = dependencyComponentSolver((key) => {
+        const node = expand(key);
+        return { locallyComplete: node.admitted, seed: node.seed, dependencies: node.dependencies };
+    }, 'seeded-origin');
+    return (key) => {
+        const result = solve(key);
+        return result.status === 'refused' ? 'refused' : result.grounded ? 'allocated' : 'vacuous';
+    };
+};

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

@@ -0,0 +1,132 @@
+import ts from 'typescript';
+import { type SourceClass, type ValueFlowIndex } from './model.js';
+import type { ExactClassAllocationOrigins } from './member-call-forwarding.js';
+/**
+ * The declaration-only spelling `define-property-source-transform.ts` emits for
+ * a `this`-receiver `Object.defineProperties` data descriptor: a bare
+ * `/** @type {...} *\/ this.key;` access standing as its own statement.
+ *
+ * It is the DECLARATION of a data member and executes nothing -- the property
+ * is created by the definition call the transform keeps beside it, with that
+ * call's own attributes. TypeScript's JS class inference reads it as a member
+ * declaration and hands it back as the property's declaration node, so a proof
+ * that accepts `this.key = value` and refuses this one is refusing the same
+ * fact written in the spelling this compiler itself chose. Three's `LOD`
+ * declares `levels` that way, and reading it was the terminal of 35 escapes.
+ */
+export declare const declaredDataMemberAccess: (declaration: ts.Node) => boolean;
+/** A declared descriptor family and a value's allocation family are distinct queries. */
+export type SourceClassFamilyQuery = {
+    readonly kind: 'declared';
+    readonly receiver: ts.Type;
+} | {
+    readonly kind: 'value';
+    readonly receiver: ts.Type;
+    readonly expression: ts.Expression;
+    readonly originsOf: (expression: ts.Expression) => ExactClassAllocationOrigins | null;
+};
+export declare const constructorInstalledMemberDeclarationsOf: (flow: ValueFlowIndex, owner: SourceClass) => ReadonlyMap<string, readonly ts.BinaryExpression[]>;
+/** A source family's inherited constructor slot, with no own override or recorded replacement. */
+export declare const sourceClassConstructorSlotIsOriginal: (checker: ts.TypeChecker, flow: ValueFlowIndex, query: SourceClassFamilyQuery) => boolean;
+export declare const classConstructorSlotIsOriginal: (checker: ts.TypeChecker, flow: ValueFlowIndex, owner: SourceClass) => boolean;
+/** A descriptor-family proof, not a receiver-origin or escape proof. The
+ * caller already follows a particular source owner through its aliases.
+ * Unrelated function constructors with checker type `any` must not become
+ * members of that owner's family merely through structural assignability.
+ */
+export declare const sourceClassDataMemberPlanOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, query: SourceClassFamilyQuery, key: string) => {
+    readonly declarations: readonly ts.Declaration[];
+} | null;
+export declare const sourceClassDataMemberOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, receiver: ts.Type, key: string) => boolean;
+/**
+ * The source method bodies a key resolves to on this class family.
+ *
+ * A sibling of `sourceClassDataMemberPlanOf`, deliberately not a widening of
+ * it. They answer different questions -- "what plain data does this key hold"
+ * and "which bodies does this key dispatch to" -- and a consumer asking the
+ * first must keep getting `null` for a method, so they get separate caches as
+ * well as separate names.
+ *
+ * **Slot integrity is not proven here, and that separation is the point.**
+ * `ownedClassReceiverInventoryOf` admits a family only when
+ * `classConstructorKeepsInstanceOf` holds for every class in it, and that
+ * inventory refuses any constructor or prototype reference it cannot explain,
+ * `C.prototype.m = other` included. What remains -- an instance-side `a.m = f`
+ * -- belongs to whoever holds the construction: the value graph's slot transfer
+ * enumerates every write to this key on that allocation and refuses the ones it
+ * cannot model. This function answers only which declarations the key names,
+ * which is §4's distinction between a virtual callable slot and prototype-slot
+ * integrity, kept apart on purpose.
+ */
+export declare const sourceClassCallableMemberPlanOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, query: SourceClassFamilyQuery, key: string) => {
+    readonly declarations: readonly ts.Declaration[];
+} | null;
+/** How one family class answers a read of the key: no member anywhere on its
+ * chain, a plain data member, or something that runs code or cannot be seen. */
+export type SourceClassKeyRead = 'absent' | 'data' | 'other';
+export interface SourceClassKeyReadPlan {
+    /** Every class the receiver can be an instance of, classified for the key. */
+    readonly classes: ReadonlyMap<SourceClass, SourceClassKeyRead>;
+    /** The declared data member of every `data` class, with its checker carrier. */
+    readonly carriers: readonly {
+        readonly owner: SourceClass;
+        readonly declaration: ts.Declaration;
+        readonly type: ts.Type;
+    }[];
+    /** No class on any family chain has a method, accessor or unseen member for the key. */
+    readonly codeFree: boolean;
+    /** Every carrier is a primitive, `null` or `undefined`: the read can never yield an object. */
+    readonly primitive: boolean;
+    /** Some class lacks the key, so its read falls through to the intrinsic Object prototype. */
+    readonly needsDefaultPrototype: boolean;
+    /** Complete source setters a plain assignment can execute, or null when its effects are opaque. */
+    readonly writeBodies: readonly ts.SetAccessorDeclaration[] | null;
+    /** Complete source getters a read executes, or null when a read's effects are opaque (a method, an unseen member kind, a bodiless getter). */
+    readonly readBodies: readonly ts.GetAccessorDeclaration[] | null;
+}
+/**
+ * A read of `key` through a receiver of this source class family, classified
+ * per class -- including keys the receiver's own class never declares.
+ *
+ * Three's renderer asks every drawable `object.isInstancedMesh` and
+ * `object.isSkinnedMesh` (`WebGLRenderLists.js`, `WebGLObjects.js`,
+ * `WebGLPrograms.js`, ...). Only `InstancedMesh`/`SkinnedMesh` declare them,
+ * and neither is in the three.js app's import graph, so on a `Mesh` the read is simply
+ * absent. The read runs no code exactly when no class in the family -- nor
+ * any class on its prototype chain up to `Object.prototype` -- has a method
+ * or accessor for the key. An absent key further needs the key not to be an
+ * `Object.prototype` member and the intrinsic Object prototype intact (the
+ * same ledger obligation a record's missing slot pays).
+ *
+ * `carriers`/`primitive` let a caller that follows the receiver require that
+ * the read can never yield the receiver back (`this.self = this`) or a
+ * function that captures it. "Absent" states that no class DECLARES the key;
+ * an expando store onto an instance is a store the caller's own publication
+ * tracking must see. Like the data plan, this assumes a receiver typed as a
+ * family class really holds a family instance.
+ */
+export declare const sourceClassKeyReadPlanOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, query: SourceClassFamilyQuery, key: string) => SourceClassKeyReadPlan | null;
+/**
+ * Whether any reflective definition anywhere in the program -- `Object.defineProperty`/
+ * `defineProperties`, `Reflect.defineProperty`, `x.__defineGetter__`/`__defineSetter__`,
+ * a prototype swap, or an unaccounted-for alias of one of the `Object`/`Reflect`
+ * mutators -- could install a GETTER under `key` on some object.
+ *
+ * `sourceClassKeyReadPlanOf` classifies a key from the checker's own STATIC
+ * declared members; it has no way to see an accessor a reflective call
+ * installs on one instance at runtime, on a class the checker still types as
+ * plain data. A member-read proof built on that plan must refuse whenever
+ * this holds, however data-only the plan itself says the family is.
+ *
+ * Deliberately conservative and receiver-blind: it does not try to prove the
+ * reflective call's TARGET cannot be one of this proof's family instances --
+ * that precision is `class-family-member-read.ts`'s own (unexported)
+ * `reflectionMayCreate`, not reused here because importing it would cycle
+ * back through `callable-reach.ts`, which `class-family-member-read.ts`
+ * itself imports (`closedCallableAuthorityOf`). Over-refusing is always
+ * sound: this can only ever make a read refuse, never accept one it should
+ * not have. `Object.assign`/`Reflect.set` are deliberately excluded -- both
+ * write through [[Set]], which invokes an EXISTING accessor or creates a
+ * plain data property, but installs no new one.
+ */
+export declare const reflectiveDefinitionMayInstallGetterOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, key: string) => boolean;