@geastack/compiler 1.0.15

package/dist/semantics/normalize/omitted-stated-parameter.d.ts

@@ -0,0 +1,53 @@
+import ts from 'typescript';
+/**
+ * A JavaScript parameter whose JSDoc states its type, but which some caller
+ * leaves out.
+ *
+ * The declaration overlay now carries `@types/three`'s parameter types into
+ * three's own sources, and `.d.ts` files state what a well-typed caller
+ * passes -- not what three itself passes. `WebGLState`'s `ColorBuffer`:
+ *
+ *     // @param {boolean} premultipliedAlpha      (required in the .d.ts)
+ *     setClear: function ( r, g, b, a, premultipliedAlpha ) {
+ *       if ( premultipliedAlpha === true ) { ... }
+ *     }
+ *
+ *     colorBuffer.setClear( 0, 0, 0, 1 );                // WebGLState
+ *     _state.buffers.color.setClear( 0, 0, 0, 0 );       // WebGLShadowMap
+ *
+ * A readable JSDoc type keeps a parameter out of the census's inference
+ * (`isUnannotated`), and the tag is no optionality mark, so the parameter
+ * kept its bare statement: a `scalar(boolean)` slot, which the emitter then
+ * correctly refused to call with the `undefined` ECMAScript binds for an
+ * argument the call does not pass.
+ *
+ * The parameter's real value set is the statement's values plus that
+ * `undefined` when at least one caller omits the argument and every argument
+ * a caller does pass is a value the statement admits. A passed value outside
+ * the statement is a disagreement this rule does not paper over, and an
+ * argument a spread may or may not supply is unknown; both refuse. A caller
+ * set the census cannot close does NOT: a caller it cannot see is held to the
+ * statement exactly as it is when this rule is silent, so it adds nothing the
+ * widened type lacks, and cannot remove the omission a visible caller makes.
+ * A DEFAULTED parameter is not this case (the default answers the omission),
+ * nor an OPTIONAL one (`withDeclaredAbsence` already joins the absence), nor a
+ * rest or destructured one.
+ */
+export type OmittedStatedParameterAnswer = {
+    readonly type: ts.Type;
+} | {
+    readonly refused: string;
+};
+/** The JSDoc statement of a JavaScript parameter this rule may widen, or `null`. */
+export declare const omissionStatedTypeOf: (checker: ts.TypeChecker, parameter: ts.ParameterDeclaration) => ts.Type | null;
+/**
+ * `stated | undefined` when some caller in the (already closed) caller set
+ * omits the argument at `index`.
+ *
+ * `null` when no caller provably omits it -- every caller passes it, or there
+ * is no attributed caller at all -- so the statement stands as written and
+ * this rule has nothing to say (and nothing to refuse). Omission is decided
+ * first for that reason: only a parameter some call really leaves out is
+ * this rule's business.
+ */
+export declare const statedParameterWithOmission: (checker: ts.TypeChecker, stated: ts.Type, index: number, calls: readonly (ts.CallExpression | ts.NewExpression)[], argumentsOf: (call: ts.CallExpression | ts.NewExpression) => readonly ts.Expression[] | undefined, argumentType: (argument: ts.Expression) => ts.Type | null) => OmittedStatedParameterAnswer | null;

package/dist/semantics/normalize/omitted-stated-parameter.js

@@ -0,0 +1,59 @@
+import ts from 'typescript';
+import { annotationStatesNothing, containsUnstatedPosition, isUnusableEvidence, jsDocTypeStatesNothing } from './derived-expression-type.js';
+/** The JSDoc statement of a JavaScript parameter this rule may widen, or `null`. */
+export const omissionStatedTypeOf = (checker, parameter) => {
+    if ((parameter.flags & ts.NodeFlags.JavaScriptFile) === 0)
+        return null;
+    if (parameter.dotDotDotToken || parameter.initializer || !ts.isIdentifier(parameter.name))
+        return null;
+    if (checker.isOptionalParameter(parameter))
+        return null;
+    const tag = ts.getJSDocType(parameter);
+    if (!tag || jsDocTypeStatesNothing(checker, tag))
+        return null;
+    const stated = checker.getTypeFromTypeNode(tag);
+    if (isUnusableEvidence(stated) || (stated.flags & ts.TypeFlags.Unknown) !== 0)
+        return null;
+    if (annotationStatesNothing(checker, tag, stated))
+        return null;
+    // A statement with a hole in it is not this rule's to publish. The overlay
+    // spells `@param {Array<Light>}` in files that never import `Light`, which
+    // the checker reads as `any[]`; `jsdoc-type-names.ts` resolves such names
+    // one census further out. A binding published here would outrank it with
+    // the `any` element, and every typed array a caller passes would then need
+    // a conversion into a dynamic-element array, which no runtime installs.
+    if (containsUnstatedPosition(checker, tag, stated))
+        return null;
+    return stated;
+};
+/**
+ * `stated | undefined` when some caller in the (already closed) caller set
+ * omits the argument at `index`.
+ *
+ * `null` when no caller provably omits it -- every caller passes it, or there
+ * is no attributed caller at all -- so the statement stands as written and
+ * this rule has nothing to say (and nothing to refuse). Omission is decided
+ * first for that reason: only a parameter some call really leaves out is
+ * this rule's business.
+ */
+export const statedParameterWithOmission = (checker, stated, index, calls, argumentsOf, argumentType) => {
+    // `new F` with no argument list passes nothing at all.
+    const argumentLists = calls.map((call) => argumentsOf(call) ?? []);
+    // A spread at or before the position may or may not reach it.
+    const reachedBySpread = (args) => args.slice(0, index + 1).some(ts.isSpreadElement);
+    if (!argumentLists.some((args) => args[index] === undefined && !reachedBySpread(args)))
+        return null;
+    for (const args of argumentLists) {
+        if (reachedBySpread(args))
+            return { refused: 'stated-omission-spread-argument' };
+        const argument = args[index];
+        if (!argument)
+            continue;
+        const type = argumentType(argument);
+        if (!type || isUnusableEvidence(type) || (type.flags & ts.TypeFlags.Unknown) !== 0)
+            return { refused: 'stated-omission-argument-unresolved' };
+        if (!checker.isTypeAssignableTo(type, stated))
+            return { refused: 'stated-omission-argument-not-assignable' };
+    }
+    return { type: checker.getNullableType(stated, ts.TypeFlags.Undefined) };
+};

package/dist/semantics/normalize/open-type-form.d.ts

@@ -0,0 +1,10 @@
+import ts from 'typescript';
+/**
+ * An unreduced generic expression cannot supply a physical carrier. A
+ * polymorphic receiver is different: the checker authenticates its class or
+ * interface through the same symbol on the constraint. Follow that constraint
+ * without instantiating anything; a generic receiver remains open when its
+ * own type arguments are open. Ordinary `T extends Renderer` has T's distinct
+ * symbol, so its constraint must not be mistaken for a concrete argument.
+ */
+export declare const isOpenTypeForm: (type: ts.Type, seen?: Set<ts.Type>) => boolean;

package/dist/semantics/normalize/open-type-form.js

@@ -0,0 +1,32 @@
+import ts from 'typescript';
+/**
+ * An unreduced generic expression cannot supply a physical carrier. A
+ * polymorphic receiver is different: the checker authenticates its class or
+ * interface through the same symbol on the constraint. Follow that constraint
+ * without instantiating anything; a generic receiver remains open when its
+ * own type arguments are open. Ordinary `T extends Renderer` has T's distinct
+ * symbol, so its constraint must not be mistaken for a concrete argument.
+ */
+export const isOpenTypeForm = (type, seen = new Set()) => {
+    if (seen.has(type))
+        return false;
+    seen.add(type);
+    if ((type.flags & ts.TypeFlags.TypeParameter) !== 0) {
+        const constraint = type.getConstraint();
+        const symbol = type.getSymbol();
+        if (constraint &&
+            symbol &&
+            symbol === constraint.getSymbol() &&
+            (symbol.flags & (ts.SymbolFlags.Class | ts.SymbolFlags.Interface)) !== 0)
+            return isOpenTypeForm(constraint, seen);
+        return true;
+    }
+    const open = ts.TypeFlags.Conditional | ts.TypeFlags.IndexedAccess | ts.TypeFlags.Index | ts.TypeFlags.Substitution;
+    if ((type.flags & open) !== 0)
+        return true;
+    if (type.isUnionOrIntersection())
+        return type.types.some((member) => isOpenTypeForm(member, seen));
+    const reference = type;
+    const args = (type.flags & ts.TypeFlags.Object) !== 0 ? (reference.typeArguments ?? []) : [];
+    return args.some((argument) => isOpenTypeForm(argument, seen));
+};

package/dist/semantics/normalize/parameter-bindings.d.ts

@@ -0,0 +1,361 @@
+import ts from 'typescript';
+import { type ImplicitArgumentsTuple } from './implicit-arguments-tuple.js';
+import { type ArgumentsObjectCensus } from './arguments-objects.js';
+import { type CensusRefusal } from './census-refusal.js';
+import type { ExplicitThisCallFrame, FlowInvocationOperands, ValueFlowIndex } from './flow/model.js';
+import { type AliasEvidence } from './derived-expression-type.js';
+import { type ProgramReachability } from './reachability.js';
+/**
+ * The type a parameter the program never annotated is actually called with.
+ *
+ * An unannotated parameter in a JavaScript file is typed `any` by the checker.
+ * That answer describes where TypeScript looked, not what the program says:
+ * TypeScript infers a parameter's type from its annotation and from nothing
+ * else, and never from the arguments a call passes it. `function WebGLTextures(
+ * _gl, extensions, state, ... )` is called exactly once in a program, from
+ * `WebGLRenderer`, with seven arguments whose types are all known -- so the
+ * types exist, they are simply not written down anywhere the checker consults.
+ *
+ * This is the same shape of question `structural-layout-type.ts` already
+ * answers for an evolving array, one level up: the checker HAS the answer, and
+ * this asks it at the location where the checker has one. It is emphatically
+ * not the compiler inventing a type. Every type this module produces came out
+ * of the checker -- either as an argument's own type at a call site, or as the
+ * checker's answer about a member of one. What the module contributes is the
+ * connection between the two, which is the part TypeScript does not make.
+ *
+ * ## Why this is not the boxed carrier's business
+ *
+ * `representation/model.ts` admits the dynamic carrier for exactly four
+ * reasons, one of which is "the program itself declared `any`/`unknown` and
+ * never narrowed it". A parameter with no annotation declared NOTHING. Filing
+ * it under that reason reads the absence of a statement as a statement, which
+ * is how 925 unannotated parameters in three.js's renderer came to cascade
+ * 33,275 boxed carriers through a program whose types are all knowable.
+ *
+ * A parameter the program DID annotate `: any` is untouched here, and must be:
+ * that one is a statement, and honoring it is the rule working.
+ *
+ * ## What it refuses
+ *
+ * Every refusal below leaves the parameter exactly as it is today -- `any`,
+ * boxed -- because a wrong type is far worse than a boxed one:
+ *
+ * - a function whose name escapes to any position other than the callee of a
+ *   call this census resolved back to it. A function held as a value can be
+ *   called from somewhere this enumeration cannot see, and a parameter bound
+ *   from a partial view of its callers is bound from a guess.
+ * - a parameter assigned anywhere in its own body. Its value is then not the
+ *   argument's, and the argument's type is not its type.
+ * - call sites that disagree. Agreement is never tested by spelling. Two sites
+ *   passing the same interned checker type describe one value shape; sites
+ *   passing different types agree only when one of those types provably holds
+ *   all the others, which the checker itself decides. Anything else is refused
+ *   rather than merged into a union nobody wrote -- see `widestOf`.
+ * - a rest parameter, a destructured parameter, and any argument whose own type
+ *   is still `any` -- propagating `any` is what this exists to stop.
+ */
+export interface ParameterBindingCensus {
+    /** Known executable destinations, including aliases and overrides. Positive evidence, not a proof that no opaque target exists. */
+    readonly callTargetsAt?: (call: ts.CallExpression | ts.NewExpression) => readonly ts.SignatureDeclaration[] | null;
+    /** The settled static call attribution, before alias/override argument fan-out. This is not an effect or escape proof. */
+    readonly callDeclarationAt?: (call: ts.CallExpression | ts.NewExpression) => ts.SignatureDeclaration | ts.JSDocSignature | null;
+    /**
+     * A `.call`/`.apply` reading proven sound for a call whose receiver's
+     * checker type gave `unwrapExplicitThisCall` nothing to unwrap statically --
+     * feeds `indexValueFlow`'s `censusExplicitThisAt` so the NEXT round's whole
+     * flow index (not just this census's own target attribution) is built from
+     * the corrected operand frame. `null` is the normal case: most `.call`/
+     * `.apply` sites resolve statically and never reach this proof at all.
+     */
+    readonly explicitThisAt?: (call: ts.CallExpression) => ExplicitThisCallFrame | null;
+    /** The complete read-only arguments frame, per position, owned by a source signature. */
+    readonly implicitArgumentsTupleAt?: (owner: ts.Node) => ImplicitArgumentsTuple | null;
+    /**
+     * The type this node holds once unannotated parameters carry what their
+     * callers pass, or `null` when nothing here improves on the checker's answer.
+     *
+     * `null` is the normal case and the safe one: it means "the checker's answer
+     * stands", so a program with no unannotated parameters is untouched.
+     */
+    readonly typeAt: (node: ts.Node) => ts.Type | null;
+    /**
+     * What an ARRAY-PATTERN element READS out of its source before its default
+     * runs -- `T | undefined` off an array, the position's own type off a
+     * tuple -- as against `typeAt(element)`, the type the NAME is bound to
+     * once the default has resolved the absence. The destructuring producer
+     * types the extraction step with this and the binding with the other; see
+     * `producers/destructuring.ts`'s `extractedArrayTypeOf`.
+     */
+    readonly patternReadTypeAt?: (element: ts.BindingElement) => ts.Type | null;
+    /** A construction proof that is intentionally stronger than a usable checker answer. */
+    readonly preferredTypeAt?: (node: ts.Node) => ts.Type | null;
+    /**
+     * The narrowing a STATED parameter's annotation left room for -- see
+     * `statedUpperBound` and `narrowsOnlyUnstatedPositions`. `null` everywhere
+     * else, which is every node in a program whose annotations constrain every
+     * position they mention.
+     *
+     * Separate from `typeAt` because the two are read by different authorities
+     * under different guards. `typeAt` is consulted only where the checker had
+     * NOTHING (`structural-layout-type.ts`'s `any`/vacuous guard), which is the
+     * right rule for a parameter that stated no type and the wrong one here:
+     * the checker has a perfectly good answer for `matchResult: Result<[unknown,
+     * RouterRoute]>` and it is the answer that has to be overridden. Answered
+     * for the declaration AND for every identifier that reads it, because a
+     * parameter and its reads are one storage cell, and a cell whose slot
+     * narrowed while its reads did not is the two-authority split this exists
+     * to avoid (measured directly: 3 lowering blockers reading "parameter 0 is
+     * bound as X but the ABI declares Y").
+     */
+    readonly statedTypeAt: (node: ts.Node) => ts.Type | null;
+    /**
+     * The member list for a SYNTHESIZED disjoint-union carrier at this node, or
+     * `null` wherever `typeAt` already answers or no union applies. Answers
+     * what `typeAt` structurally cannot: `ts.TypeChecker.getUnionType` is not
+     * public, so `derived-expression-type.ts`'s `disjointUnionMembersOf` hands
+     * back the member list for `structural.ts` to `table.intern` directly.
+     */
+    readonly unionArmsAt: (node: ts.Node) => readonly ts.Type[] | null;
+    /**
+     * The argument EXPRESSIONS whose types `typeAt`/`unionArmsAt` folded for a
+     * parameter. The census speaks in checker types, and a checker type is not
+     * always the whole answer: `Date.prototype` types as a Date instance while
+     * the structural layer carries it as the prototype object itself
+     * (`prototypeObjectTypeAt`). Exposing the nodes lets that layer re-ask its
+     * own question of what was passed instead of trusting the checker's image.
+     */
+    readonly argumentsAt?: (parameter: ts.ParameterDeclaration) => readonly ts.Expression[] | null;
+    /**
+     * The array ELEMENT an UNANNOTATED rest parameter is called with, joined
+     * across every reachable call site's variable-width TAIL -- `null` when
+     * there is no such join (no call sites, an unresolved or spread argument
+     * anywhere in the tail, or a genuine disagreement `joinOfWrites` cannot
+     * settle). `structural-parts.ts`'s `parameterOf` (the ABI's rest slot) and
+     * `structural.ts`'s `rest-parameter-array-element` rule (every body-side
+     * reference to the same parameter) both read this, so the signature and
+     * the body it wraps publish the identical element and can never disagree
+     * about it -- see `parameter-slot.ts`'s `restParameterArrayTypeOf` header
+     * for why that agreement is the whole point.
+     *
+     * Deliberately its own field rather than a `typeAt`/`unionArmsAt` answer:
+     * both of those publish the WHOLE value a node holds, unwrapped, and a
+     * rest parameter's element is not that -- it still needs wrapping in the
+     * `array` shape the language always constructs it as, exactly as
+     * `restParameterArrayTypeOf`'s own already-widened element does.
+     */
+    readonly restElementTypeAt?: (parameter: ts.ParameterDeclaration) => ts.Type | null;
+    /** How many parameters this census bound, for measurement. */
+    readonly boundCount: number;
+    /**
+     * Why each parameter this census could not bind was refused, one entry per
+     * refused parameter, carrying that parameter as `owner`.
+     *
+     * A refusal here is not a defect -- every one of them leaves the checker's
+     * answer standing, which is the behaviour before this module existed. It
+     * used to be a `ReadonlyMap<string, number>`, a count per prose reason with
+     * no owner: a count says a cell went untyped but not WHICH cell, so nothing
+     * downstream could act on one. `censusRefusalCounts` derives the old shape
+     * for a caller that only ever wanted the tally.
+     */
+    readonly refusals: readonly CensusRefusal[];
+    /** Why this particular parameter was not bound, for attributing one declaration rather than a total. */
+    readonly refusalOf: (parameter: ts.ParameterDeclaration) => string | null;
+    /** Every refused parameter with its reason, one per line -- `GEA_BINDING_DEBUG` only. */
+    readonly debugReport?: () => string;
+}
+/** A census that binds nothing, for callers that state no program. */
+export declare const emptyParameterBindingCensus: ParameterBindingCensus;
+/**
+ * Whether a type still carries a piece of an UNSUBSTITUTED generic -- a bare
+ * type parameter, an indexed access whose object type is one (`E['Bindings']`),
+ * a conditional or a substitution.
+ *
+ * Such a type is not a carrier and never becomes one: the representation
+ * deriver has nothing to resolve `E['Bindings']` against and publishes
+ * `unresolved(...)`, which fails preflight as an unmet obligation rather than
+ * as a refusal anyone can read. hono's `Hono` is generic in `E` and every
+ * copy of it shares one parameter node, so a census answer taken from a call
+ * site INSIDE the generic carries `E` out with it -- 10 unmet obligations
+ * reading "an indexed access whose object type is still a type parameter has
+ * no member set to resolve", measured the first time this admission ran
+ * without the guard.
+ */
+export declare const carriesUnsubstitutedGeneric: (checker: ts.TypeChecker, type: ts.Type, depth?: number) => boolean;
+/**
+ * An UNANNOTATED rest parameter this census considers for its own,
+ * element-wise join -- see `restElementTypeAt`. Kept separate from
+ * `ParameterCandidate`: a rest parameter's physical slot is never one
+ * argument's type (what the ordinary sweep below binds), it is the ARRAY
+ * the language always constructs, and its element is a join over every
+ * call's variable-width TAIL rather than one fixed ordinal.
+ */
+interface RestParameterCandidate {
+    readonly declaration: ts.SignatureDeclaration;
+    readonly parameter: ts.ParameterDeclaration;
+    /** The rest parameter's own ordinal -- where its variable-width tail starts at every call site. */
+    readonly index: number;
+}
+/** One parameter this census is considering, and the annotation it may only narrow WITHIN -- see `statedUpperBound`. */
+interface ParameterCandidate {
+    readonly declaration: ts.SignatureDeclaration;
+    readonly parameter: ts.ParameterDeclaration;
+    readonly index: number;
+    /** `null` for an unannotated parameter. */
+    readonly stated: ts.Type | null;
+    /** The open dynamic object boundary whose flow-narrowed physical arms must remain distinct. */
+    readonly flowCarrierUpperBound: ts.Type | null;
+}
+/**
+ * The program-wide evidence `censusParameterBindings` reads and never rewrites.
+ *
+ * Every entry here is a fact about the program's syntax and the checker's own
+ * answers, so it is the same in every round: which symbol each identifier
+ * resolves to, which declaration the checker attributes each call to, which
+ * symbols are assigned and with what, which parameters are candidates at all.
+ * None of it can improve as bindings accumulate -- that is what the fixpoint
+ * inside the census is for, and what `callsByDeclaration` (rewritten every
+ * round by `attributeCalls`) is deliberately NOT part of.
+ *
+ * It is hoisted out because the census does not run once. `frontend.ts`
+ * composes it against its own settled output until `boundCount` stops moving,
+ * which is 5 rounds on the three.js app, and each round used to rebuild all
+ * of this from scratch: a `getSymbolAtLocation` for every identifier in the
+ * program, a `getResolvedSignature` for every call, `isUnannotated` and
+ * `statedUpperBound` for every parameter, and the whole alias index. Built
+ * once and passed in, the checker answers each of those questions a fifth as
+ * often.
+ *
+ * Passed as an argument rather than memoized in module state, for the reason
+ * `CLAUDE.md` gives: this module is functions plus factory-created state, and
+ * a cache living in the module would be shared across programs -- every entry
+ * here is keyed by nodes and symbols belonging to ONE checker.
+ */
+/**
+ * One write an assignment makes into a parameter's own cell.
+ *
+ * `operatorTyped` marks the writes whose type the OPERATOR fixes rather than
+ * the operands: `r *= a` yields a number whatever `r` and `a` held, `s += 'a'`
+ * a string, `n++` a number. For those the flow layer deliberately records no
+ * value expression (`ValueWrite.value` is `null`, because there is no
+ * sub-expression holding the written value), and the honest evidence is the
+ * type of the whole assignment expression -- which is `site`.
+ */
+export interface AssignedWrite {
+    readonly expression: ts.Expression;
+    readonly operatorTyped: boolean;
+}
+export interface ParameterBindingProgramIndex {
+    readonly implicitArgumentsUses: ReadonlyMap<ts.SignatureDeclaration, readonly ts.Identifier[]>;
+    readonly valueFlow: ValueFlowIndex;
+    readonly candidates: readonly ParameterCandidate[];
+    /** Every UNANNOTATED rest parameter this census may join an element type for -- see `restElementTypeAt`. */
+    readonly restParameterCandidates: readonly RestParameterCandidate[];
+    /** `candidates` minus the ones a reassignment already refuses. */
+    readonly notReassigned: readonly ParameterCandidate[];
+    /** The candidates a reassignment refuses, kept (not just counted) so the refusal can name which parameter. */
+    readonly reassigned: readonly ParameterCandidate[];
+    /** Stated JS parameters outside inference that a caller may still leave out -- see `omitted-stated-parameter.ts`. */
+    readonly omissionSites: readonly {
+        readonly declaration: ts.SignatureDeclaration;
+        readonly parameter: ts.ParameterDeclaration;
+        readonly index: number;
+        readonly stated: ts.Type;
+    }[];
+    readonly assigned: ReadonlySet<ts.Symbol>;
+    /**
+     * What each in-body assignment writes into a reassigned parameter's own
+     * cell, keyed by the parameter's symbol -- `null` once any such write states
+     * only that a write HAPPENED, since a join cannot be taken over evidence
+     * that was never produced.
+     */
+    readonly assignedEvidence: ReadonlyMap<ts.Symbol, readonly AssignedWrite[] | null>;
+    readonly allCalls: readonly (ts.CallExpression | ts.NewExpression)[];
+    readonly checkerAttribution: ReadonlyMap<ts.CallExpression | ts.NewExpression, ts.Declaration | null>;
+    readonly invocationOperands: ReadonlyMap<ts.CallExpression | ts.NewExpression, FlowInvocationOperands>;
+    readonly aliasEvidence: AliasEvidence;
+    /** Which methods override each base method, so a virtual call's evidence reaches every override. */
+    readonly overridesOfBaseMethod: ReadonlyMap<ts.Declaration, readonly ts.MethodDeclaration[]>;
+    /**
+     * Every OTHER body that publishes the same member symbol as a given
+     * callable: a class's own declared method alongside every `receiver.<name>
+     * = function ( ... ) { ... }` instance override of the identical key, keyed
+     * by symbol identity (never by name spelling alone).
+     */
+    readonly siblingMemberDeclarations: ReadonlyMap<ts.Declaration, readonly ts.SignatureDeclaration[]>;
+}
+export declare const indexParameterBindingProgram: (checker: ts.TypeChecker, files: readonly ts.SourceFile[], reachable: ProgramReachability, valueFlow?: ValueFlowIndex, argumentsObjects?: ArgumentsObjectCensus) => ParameterBindingProgramIndex;
+export declare const censusParameterBindings: (checker: ts.TypeChecker, files: readonly ts.SourceFile[], reachable: ProgramReachability, 
+/**
+ * A previously composed census this round may read from, the same way
+ * `withReturnBindings` and `withLocalBindings` already take one.
+ *
+ * `censusParameterBindings` used to be the one census with no upstream at
+ * all: `return-bindings.ts` and `local-bindings.ts` both compose OVER its
+ * output, but nothing ever composed back INTO it, so it answered every
+ * question -- including "what does this call site's argument hold" -- with
+ * only the checker's own evidence and its own internal fixpoint. That is
+ * why `texture`, `attribute` and `geometry` stayed `any` in the three.js app even
+ * after the other two censuses learned their receivers: those parameters'
+ * call sites pass expressions -- `state.buffers`, `const me = m.elements`
+ * one step removed -- whose types only exist once a LATER census has run,
+ * and by the time it runs this one has already finished.
+ *
+ * Feeding a prior round's composed census in here as `upstream` closes that
+ * gap for a second round: `known()` below consults it exactly where it
+ * already falls back from "the checker has no answer" to "keep looking",
+ * ahead of this census's own machinery reconstructing one from scratch.
+ * `emptyParameterBindingCensus` (round one, and every other caller) makes
+ * this identical to the unparameterized behaviour before -- `?? null` never
+ * changes an answer this module already had.
+ *
+ * ⛔ This is also the reason `binding-fixpoint.ts` carrying only
+ * `.parameters` across the round boundary (never `.facts.valueFlow`) does
+ * NOT stop a finished round's `ValueFlowIndex` from staying reachable.
+ * `known()` and `computeStatedTypeAt()` below close over BOTH `valueFlow`
+ * (this round's own) and `upstream` (this round's WHOLE argument, not a
+ * snapshot of it) so they can answer a node neither has seen yet. The
+ * object this function returns is exactly `upstream` for the NEXT round --
+ * so round N+1's `typeAt` closes over round N's `typeAt`, which closes over
+ * round N-1's, back to round one. `sourceValueSessionOf`
+ * (`flow/source-value-session.ts`) memoizes a ~1 GB dependency-solver
+ * session in a WeakMap keyed on the `ValueFlowIndex` object identity, so
+ * every round on this chain that was ever asked a call-target/receiver
+ * question keeps its whole session alive for as long as `settled.parameters`
+ * (`frontend.ts`) is reachable -- which is the rest of the compile. Measured
+ * on the three.js app: 4 rounds, 4 live `[SOLVER]` sessions at exit, not 1.
+ *
+ * Not cut here. Forcing `known()`/`computeStatedTypeAt()` to resolve eagerly
+ * instead of lazily falling through to `upstream` would answer a node
+ * before the round that can actually answer it has run -- the exact
+ * pending-read-as-decided collapse `SEMANTIC-AUTHORITY.md` §2(b) names.
+ * Truncating the chain (answering from this round's own evidence only,
+ * dropping `upstream` once this round stops being the fixpoint's active
+ * `previousCensus`) is answer-preserving only if no node reachable after
+ * that point was going to need a fact this round's own machinery never
+ * independently derived -- true for the RECORDED node set the convergence
+ * check in `binding-fixpoint.ts` verifies, unproven for the unbounded set of
+ * nodes `frontend.ts` and every downstream producer query afterward, and
+ * unverifiable here since the emitted-set gate is off-limits mid-measurement.
+ * A real fix has `typeAt`/`statedTypeAt`/`patternReadTypeAt` take the
+ * requesting round's own `ValueFlowIndex` as a call-time argument instead of
+ * a captured one, which is a migration of the shared `ParameterBindingCensus`
+ * surface (`return-bindings.ts`, `local-bindings.ts`, `field-bindings.ts`,
+ * `structural.ts`, every producer that calls `typeAt`), not a change
+ * confined to this file.
+ */
+upstream?: ParameterBindingCensus, 
+/**
+ * The program index every round shares. Defaulted so a caller that runs the
+ * census once needs no change; `frontend.ts`, which runs it up to eight
+ * times, builds it once and passes it.
+ */
+index?: ParameterBindingProgramIndex, 
+/**
+ * The current round's value-flow facts. The reusable program index owns
+ * syntax discovery, not the evolving call attribution and collection edges.
+ * A one-shot census can use its index's flow; a composed census must receive
+ * the same round snapshot as the field, local, return and collection censuses.
+ */
+valueFlow?: ValueFlowIndex) => ParameterBindingCensus;
+export {};