@geastack/compiler 1.0.15

package/dist/semantics/normalize/derived-expression-type.d.ts

@@ -0,0 +1,1070 @@
+import ts from 'typescript';
+export { isOpenTypeForm } from './open-type-form.js';
+import { type ProgramReachability } from './reachability.js';
+import { type ExplicitThisCallFrame, type FlowInvocationOperands, type ValueFlowIndex } from './flow/model.js';
+/**
+ * Whether a type says nothing about STORAGE, and so is not evidence.
+ *
+ * The ONE copy. `parameter-bindings.ts` and `return-bindings.ts` each carried
+ * their own before this, with `parameter-bindings.ts`'s adding bare
+ * `Function` on top -- it still does, by composing with this rather than
+ * restating it, so the base three flags cannot drift between the three
+ * modules that ask this question. That module's own `isUnusableEvidence`
+ * carries the long-form reasoning for `any`, `void` and `never`.
+ *
+ * `annotationStatesNothing` is the fourth member and the reason this became
+ * shared: a value typed `object` or `{}` is not `any`, so every one of these
+ * copies read it as real evidence and published it -- and the parameter
+ * census's answer SHADOWS the return census's in the composed view
+ * (`composeReturnBindings`), so `function makesBag(): object { return { a: 1,
+ * b: 2 } }` had its call answered `object` by one census while the other had
+ * already derived the real record. Two authorities, one call, and
+ * `model/selected-signature.ts`'s fail-closed guard caught it as a withheld
+ * producer. A type that states nothing is not evidence here for exactly the
+ * reason `any` is not.
+ */
+/**
+ * The destructuring TARGET an object or array literal is written against,
+ * when that target is a binding pattern whose type TypeScript merely IMPLIED
+ * from the pattern's shape: `const [a, b] = [1, 2]`, `[a, b] = [1, 2]`,
+ * `f([1, 2])` for `function f([x, y])`, `function g({ x } = { x: 1 })`. The
+ * checker contextually types such a literal from the pattern -- a tuple, or
+ * a record of `any` fields -- while the value is exactly what was written:
+ * nothing in the program stated a type, and the language binds the pattern
+ * off whatever arrives. `null` for a literal in any other position,
+ * including one whose target DECLARES its type, which stays what it states.
+ * The returned parameter is the census's cell for the value when the target
+ * is a parameter, so an empty literal can take its element from what the
+ * other call sites pass rather than from nothing. `element` names the nested
+ * binding element whose DEFAULT the literal is: that literal is stored in
+ * the element's own slot, never in the root parameter's.
+ */
+export declare const impliedPatternTargetOf: (checker: ts.TypeChecker, node: ts.ArrayLiteralExpression | ts.ObjectLiteralExpression) => {
+    readonly parameter: ts.ParameterDeclaration | null;
+    readonly element?: ts.BindingElement;
+} | null;
+/**
+ * The parameter whose DESTRUCTURING PATTERN `node` is or names, when the
+ * pattern's type is one TypeScript merely IMPLIED from the pattern's shape --
+ * `function f([x, y])`, `function g({ a, b })` -- with no annotation and no
+ * JSDoc tag. That implied type (`[any, any]`, `{ a: any; b: any }`) is a
+ * statement about the binding's SYNTAX, not about any value a caller passes:
+ * the language binds an array pattern off any iterable of any length, and an
+ * object pattern off any object. So for every question this compiler asks --
+ * does the parameter state a type (no: the census binds it from the call
+ * sites), is the pattern's own type real (no: it is its source's) -- the
+ * pattern is "unannotated", and this one predicate is what every site asks so
+ * the census, the layout resolver and the ABI projection agree by
+ * construction. `null` for a named parameter, an annotated pattern, or a
+ * pattern that is not a parameter's own name.
+ */
+export declare const impliedPatternParameterOf: (checker: ts.TypeChecker, node: ts.Node) => ts.ParameterDeclaration | null;
+/**
+ * The implied-pattern parameter a binding element belongs to, or `null`. The
+ * checker types every name in `function f([w = c()])` from the pattern's own
+ * silhouette -- `void` here, because the default is the only evidence it has
+ * -- and that silhouette is the thing `impliedPatternParameterOf` exists to
+ * see through: a layout consult that trusts it skips the census that holds
+ * the callers' actual writes. An identifier declared by such an element is
+ * the same question asked at a read.
+ */
+export declare const impliedPatternElementRootOf: (checker: ts.TypeChecker, node: ts.Node) => ts.ParameterDeclaration | null;
+export declare const isUnusableEvidence: (type: ts.Type) => boolean;
+/**
+ * The one type among these that every other fits into, or `null` when no
+ * single member holds them all.
+ *
+ * The ONE join every census in this compiler uses -- `parameter-bindings.ts`
+ * (call-site arguments, write-sets, return expressions), `return-bindings.ts`
+ * and `local-bindings.ts` (both by way of `derivedExpressionType`, below).
+ * Kept to one copy deliberately: two joins answering the same "do these
+ * agree" question two ways is the defect class this compiler keeps
+ * rediscovering (see this file's own header comment on `derivedExpressionType`).
+ *
+ * Two writes to one cell, two calls to one parameter, two `return`s from one
+ * function: each has to settle on a single carrier, and requiring the observed
+ * types to be IDENTICAL refuses a case the program answers itself. In three's
+ * renderer `let _gl = context;` is followed by
+ * `if ( _gl === null ) _gl = getContext( ... );` -- the writes are
+ * `NativeWebGL2RenderingContext` and `NativeWebGL2RenderingContext | null`, and
+ * the null check on the very next line says which one the cell is.
+ *
+ * Nothing is invented here. The answer is always one of the types the program
+ * itself produced, admitted only because the checker says every other observed
+ * type is assignable to it -- so the storage provably holds all of them. Two
+ * unrelated types stay refused, because there the honest answer is neither, and
+ * a union of this compiler's own making would be a source-shaped guess at a
+ * carrier rather than a reading of one.
+ *
+ * A CALLING CONVENTION is the one case plain assignability gets wrong. A
+ * function declaring FEWER parameters is assignable wherever one declaring
+ * more is expected -- TypeScript lets a callee ignore an argument it never
+ * named -- so joining `(event) => void` and `() => void` by assignability
+ * alone picks `() => void`: the least informative signature, with the
+ * parameter every real call site actually passes silently dropped.
+ * `EventDispatcher.addEventListener`'s `listener` parameter, bound once bare
+ * `Function` stopped being usable evidence (`parameter-bindings.ts`'s
+ * `isUnusableEvidence`), is exactly this: joined by assignability it
+ * collapsed to `() => void` while `dispatchEvent` calls every listener with
+ * one argument, and that reached the emitter as a real ABI mismatch. Requiring
+ * the SAME arity when either side is a single-signature callable is the
+ * narrow fix -- compatible same-arity callables still agree exactly as
+ * `isTypeAssignableTo` already decided; only arity itself stops being
+ * something a join can widen away.
+ */
+/**
+ * Whether a JSDoc type node states nothing this compiler can read -- it
+ * resolves to `any`, `unknown`, or the checker's internal error type (which
+ * carries the `Any` flag).
+ *
+ * `checker.getTypeFromTypeNode` degrades to this when the node NAMES something
+ * the checker cannot bind at that site, and three.js's source does it
+ * constantly: `Box3.js` JSDoc-references `Sphere`/`Object3D`/`Triangle`/
+ * `Line3`/`Plane`/`Matrix3`/`Matrix4`/`Raycaster`/`Sprite` while its only
+ * import is `Vector3`, and every one of those resolves to `any` here.
+ *
+ * The distinction this draws is the whole point: a tag the checker CAN read is
+ * the program stating a type, and stops a census exactly as a TS annotation
+ * does. A tag that resolves to nothing is the program stating a type this
+ * compiler failed to resolve -- refusing the declaration for it is refusing it
+ * for a fact that is not there. `parameter-bindings.ts` has drawn this
+ * distinction since the call-site census landed; `return-bindings.ts` and
+ * `local-bindings.ts` did not, and bailed on the mere PRESENCE of a tag, which
+ * is why 48 of the app's three.js returns stayed `any` while the identical
+ * shape on a parameter was rescued. One predicate, three censuses.
+ */
+/**
+ * The type one member of `receiver` produces, or `null` when nothing usable
+ * comes back.
+ *
+ * ONE copy, shared by all three censuses. `parameter-bindings.ts`,
+ * `local-bindings.ts` and `field-bindings.ts` each carried a private,
+ * byte-identical version of this -- three authorities on one question, which
+ * is the defect class this compiler keeps rediscovering. The bug below lived
+ * in all three at once precisely because fixing it in one would not have been
+ * visible in the others.
+ *
+ * ## The receiver's own null is not part of the question
+ *
+ * `getPropertyOfType` on a UNION answers only with properties every member
+ * has, and `null` has none -- so `_gl.R32F`, where `_gl` is
+ * `NativeWebGL2RenderingContext | null`, came back with no property at all and
+ * the whole chain below it refused. That is not the program being unreadable;
+ * it is the question being asked of the wrong type. A member read either runs
+ * with a non-null receiver or does not run, so what the read PRODUCES is the
+ * member of the non-null receiver -- exactly what TypeScript itself answers
+ * once flow narrowing has done its work, and `structural-layout-type.ts`
+ * already asks it this way.
+ *
+ * Stripping the null cannot make an answer worse: where the receiver has no
+ * null, `getNonNullableType` is the identity, and where it does, the
+ * alternative was `null` -- the boxed carrier -- rather than some other type.
+ *
+ * Measured on the three.js app: 52 boxed identifier reads hang off `WebGLTextures.js`'s
+ * `internalFormat` cell alone, whose every write is a `_gl.<CONSTANT>` read.
+ */
+/**
+ * `resolved` when it names ONE calling convention, the convention this call
+ * site actually selected when it does not, and `null` when neither.
+ *
+ * A member can land on a method declaring more than one signature, and there is
+ * no primitive joining two overloads into one: substituting the overloaded type
+ * trades a `dynamic` carrier for an `unresolved` one -- lattice BOTTOM -- which
+ * trips `representation/verify.ts`'s `unresolved-reaches-materialization`
+ * guard. That guard is right; the defect is asking the question of the wrong
+ * node.
+ *
+ * A member read that IS a call's callee does not need its overloads joined: the
+ * program picked one, with its arguments, and TypeScript resolves exactly that
+ * with `getResolvedSignature`. Reading the type back off the selected
+ * signature's own declaration yields a single-signature function type -- the
+ * real convention this call uses. `string.split( '\n' )` in `WebGLProgram.js`
+ * is the whole of it: two `String.prototype.split` overloads, one call.
+ *
+ * NOT the refuted overload-selector. That one lived inside
+ * `resolvedCalleeSignatureType`, where the receiver had collapsed to `never` --
+ * so the overload set was a phantom and joining its arms answered a question
+ * the program never asked. Here the receiver is a real type a census bound, the
+ * overloads are real, and the SELECTION is TypeScript's own rather than one
+ * reimplemented here.
+ *
+ * An overloaded member NOT in callee position keeps its box: nothing at that
+ * site says which signature the value stands for, and guessing would give it a
+ * convention the program never chose.
+ */
+/**
+ * The type an ELEMENT read produces, when the key is not a name.
+ *
+ * `lights[ i ]`, `state.probe[ j ]`, `array[ i ]` -- the census resolvers
+ * handled only a STRING-LITERAL key, which is a named member spelled with
+ * brackets. Every other key was refused, and on the three.js app that is 470 boxed
+ * identifier reads at the root of the chain plus everything downstream of
+ * them: `const light = lights[ i ]` is the single largest one.
+ *
+ * A key not known until runtime is answered by the receiver's INDEX signature,
+ * which is the only thing that CAN answer it -- and an array's element type is
+ * exactly its numeric index signature, so `Light[]` indexed by a `number`
+ * yields `Light` with no array special-case. Which signature to ask is decided
+ * by the key's own type, resolved by the caller's own operand resolver so each
+ * census keeps its own view of what a key expression holds.
+ *
+ * A receiver with no index signature for that key comes back `null` and stays
+ * boxed: the read is then something this cannot describe, and an array whose
+ * element type TypeScript inferred as `any` is `any` again by the
+ * `isUnusableEvidence` test below rather than an improvement -- except where
+ * the caller hands over the program's value-flow index and that index proves
+ * a NUMBER key can name nothing any instance of the receiver's class family
+ * will ever hold (`absentNumericIndexTypeOf`): the read is then `undefined`.
+ */
+export declare const indexedTypeOf: (checker: ts.TypeChecker, receiver: ts.Type, key: ts.Type, at: ts.Node, flow?: ValueFlowIndex, census?: SettledReceiverCensus | null) => ts.Type | null;
+/**
+ * A settled binding census, asked for the value set of a keyed-write receiver
+ * the checker types `any` -- the same question `flow/class-family-member-read.ts`
+ * asks its `FamilyReceiverCensus`, stated here structurally so the import
+ * direction stays one way.
+ */
+export interface SettledReceiverCensus {
+    readonly typeAt: (node: ts.Node) => ts.Type | null;
+}
+/**
+ * Whether a numeric element read is proven to miss every owned class-family
+ * instance.  This is deliberately separate from `indexedTypeOf`: an
+ * `undefined` result can also come from an ordinary index signature or a
+ * checker-derived type, neither of which licenses bypassing the runtime
+ * property lookup.
+ */
+export declare const numericIndexAbsenceProven: (checker: ts.TypeChecker, flow: ValueFlowIndex, receiver: ts.Type, key: ts.Type, census?: SettledReceiverCensus | null) => boolean;
+/**
+ * Whether a NAMED property read is proven to miss every instance of a closed
+ * object-literal record -- `numericIndexAbsenceProven`'s counterpart for a
+ * named key instead of a numeric one. Deliberately separate from
+ * `memberTypeOf`: an `undefined` answer there can also come from an ordinary
+ * declared member or an array index signature, neither of which licenses a
+ * PRODUCER skipping the runtime property lookup and constant-folding the read
+ * -- only THIS proof does, which is why `producers/properties.ts` asks it
+ * directly rather than re-deriving "was it the absence arm" from
+ * `memberTypeOf`'s result.
+ */
+export declare const closedLiteralMemberAbsenceProven: (checker: ts.TypeChecker, flow: ValueFlowIndex, receiver: ts.Type, name: string, at: ts.Node) => boolean;
+/**
+ * The literal member NAME an element access spells, or `null` when its key is
+ * not a literal. `x[ 'name' ]` and `x[ 0 ]` are named reads written with
+ * brackets and resolve exactly as `x.name` does.
+ */
+export declare const literalMemberNameOf: (node: ts.ElementAccessExpression) => string | null;
+/**
+ * The one overload of `resolved` whose declared parameter count admits this
+ * call's argument count, or `null` when none or several do.
+ *
+ * Asked only when the checker resolved the call to a signature with NO
+ * declaration -- its fabricated any-call, which is what a call through an
+ * `any` receiver gets. The RECEIVER here is census-typed (`memberTypeOf` was
+ * handed it), so the member's overload set is real and only the checker's own
+ * choice among its members is missing. Counting arguments is the checker's own
+ * first step (`chooseOverload` discards every candidate the count rules out
+ * before comparing one type), so it is the step that can be repeated without
+ * the receiver the checker refused to type; a tie keeps the set whole. Three's
+ * `LOD.addLevel` is the measured case: `levels` is a descriptor-defined field
+ * the checker declares nothing for, and `levels.splice( l, 0, level )` chose
+ * the two-parameter overload by joining, so the item reached the emitter
+ * unpacked -- `Array.prototype.splice`'s renderer refused it by name.
+ */
+export declare const arityAdmittedSignature: (resolved: ts.Type, call: ts.CallExpression) => ts.Signature | null;
+export declare const singleConventionAt: (checker: ts.TypeChecker, resolved: ts.Type, node: ts.Node) => ts.Type | null;
+/** The result of an authenticated `.call`/`.apply`, read from its already-resolved underlying callable. */
+export declare const explicitThisCallReturnType: (fallback: ts.Signature, underlying: ts.Type | null) => ts.Type;
+/**
+ * An overload-independent result is knowable even when its physical call
+ * convention is not. Read every declared return through the same recovered
+ * receiver type; no overload is selected and no callable carrier is changed.
+ * Generic signatures remain the checker's instantiation question.
+ */
+export declare const overloadInvariantReturnTypeAt: (checker: ts.TypeChecker, call: ts.CallExpression | ts.NewExpression, read: (node: ts.Expression) => ts.Type | null) => ts.Type | null;
+export declare const memberTypeOf: (checker: ts.TypeChecker, receiver: ts.Type, name: string, at: ts.Node, flow?: ValueFlowIndex) => ts.Type | null;
+/**
+ * Whether a JSDoc tag resolved to nothing AT ALL -- `any` or `unknown`.
+ *
+ * Not the whole question a cell has; see `jsDocTypeStatesNothing`, which is
+ * what every cell should ask. This is only the arm that is specific to a TAG:
+ * a tag naming a type this module cannot import degrades to `any`. A tag
+ * that SPELLS `unknown` (`{unknown}`, `{?}`) is not that degradation -- it is
+ * the author's own statement, exactly as a real `unknown` annotation is
+ * (`annotationStatesNothing`), and is answered `false` below so the two
+ * spellings of one statement get one census answer.
+ */
+export declare const jsDocTypeIsUninformative: (checker: ts.TypeChecker, typeNode: ts.TypeNode) => boolean;
+/**
+ * Whether a JSDoc tag states nothing about storage -- the ONE test every cell
+ * asks of a tag, tag-specific degradation plus the identical vacuity rule a
+ * real annotation gets.
+ *
+ * Four cells asked this and each asked it differently:
+ * `parameter-bindings.ts` had a private copy that added `isEmptyObjectType`,
+ * while `return-bindings.ts`, `field-bindings.ts` and `local-bindings.ts`
+ * asked `jsDocTypeIsUninformative` alone -- so a `@param {{}}` tag was
+ * non-evidence at one cell and a stated type at the other three. Ordinary
+ * drift, of the shape this compiler keeps finding.
+ *
+ * The measured hole all four shared is `{Object}`. Three separate comments in
+ * this file asserted that TypeScript's JSDoc parser maps a capitalized
+ * `{Object}` tag to `any`, so `jsDocTypeIsUninformative` would catch it and
+ * `isGlobalObjectInterface` was documented as "not reachable from JSDoc".
+ * That is false, measured on three's `UniformsUtils.js`:
+ *
+ *     &#64;return {Object} The cloned uniforms.
+ *     export function cloneUniforms( src ) { const dst = {}; ... return dst }
+ *
+ * `getReturnTypeOfSignature` answers the REAL `lib.es5.d.ts` `Object`
+ * interface -- 7 properties, `TypeFlags.Object`, not `any` and not empty. So
+ * it passed every vacuity test, became the return cell's stated answer, and
+ * the honest `dictionary` the body builds had to convert to a named record
+ * with zero members (every one of `Object`'s members is an ambient method
+ * `structural.ts` drops). No backend can render that pair, and the whole
+ * uniforms chain downstream of it -- `parameters.uniforms`,
+ * `materialProperties.uniforms`, and the 338 boxed carriers of
+ * `WebGLMaterials.js`'s `refreshUniforms*( uniforms, material )` -- was
+ * dynamic because of one tag.
+ *
+ * Recording that premise as false is the finding; making the tag path REFUSE
+ * an `{Object}` is not the cure, and the inline comment below carries the
+ * measurement that rules it out.
+ */
+export declare const jsDocTypeStatesNothing: (checker: ts.TypeChecker, typeNode: ts.TypeNode) => boolean;
+/**
+ * Whether a resolved type is a structural object type with ZERO evidence in
+ * it: no properties, no call signature, no construct signature, no index
+ * signature.
+ *
+ * Lived in `parameter-bindings.ts` until `return-bindings.ts` needed the same
+ * question; moved here -- the module both already share for
+ * `jsDocTypeIsUninformative` and `widestOf` -- rather than copied, so the two
+ * cannot drift.
+ *
+ * `jsDocTypeIsUninformative` above catches a tag that resolves to
+ * `any`/`unknown` -- an unimported cross-module name, or the JSDoc-special
+ * `Object`/`object`. It does NOT catch this: three writes `@param {Object}
+ * data` for `InterleavedBuffer.clone( data )`, and
+ * `declaration-overlay-transform.ts`'s `replaceVagueParamTags` correctly
+ * prefers the SHIPPED declaration's answer over that vague tag -- but the
+ * shipped declaration (`@types/three`) states `clone(data: {}): ...`, and
+ * `{}` is itself a type with nothing IN it. The overlay's replacement is a
+ * real improvement in the general case (`Material.fromJSON`'s `json` gets a
+ * real `MaterialJSON`); here it swaps one uninformative spelling for another,
+ * and without this check the resolved `{}` reads as "the program stated a
+ * real type" and stays excluded from the call-site census forever, even
+ * though it states precisely as much as `any` does about what the parameter
+ * holds.
+ *
+ * The same non-evidence `parameter-bindings.ts`'s `isBareFunctionType`
+ * already is for a type with zero CALLING convention, generalized to zero
+ * MEMBER convention.
+ */
+export declare const isEmptyObjectType: (type: ts.Type) => boolean;
+/**
+ * Whether `type` IS the standard library's `name` interface -- by declaration
+ * identity, never by the symbol's own spelling. See `standardInterfaceSymbol`.
+ */
+export declare const isStandardInterfaceType: (checker: ts.TypeChecker, anchor: ts.Node, name: string, type: ts.Type) => boolean;
+/**
+ * Whether a type is the global `Object` INTERFACE -- `x: Object`, spelled as a
+ * real TypeScript annotation.
+ *
+ * The exact argument `parameter-bindings.ts`'s `isBareFunctionType` makes for
+ * bare `Function`, one level up: `Object` declares only what every value
+ * already has (`toString`, `valueOf`, `hasOwnProperty`), every non-null value
+ * is assignable to it, and it therefore states nothing about what this
+ * particular value holds. Resolved by DECLARATION IDENTITY (`isStandardInterfaceType`),
+ * so a user interface that merely declares those members -- and would once
+ * have matched on the bare spelling `'Object'` -- is not swept in beside it;
+ * only the library's own `Object` is.
+ *
+ * Reachable from JSDoc TOO, contrary to what this comment said for a long
+ * time. A capitalized `{Object}` tag does NOT degrade to `any`: measured on
+ * three's `@return {Object}`, the checker answers this very interface. See
+ * `jsDocTypeStatesNothing`, which is what makes the tag path ask.
+ *
+ * `normalize/structural.ts` interns exactly THIS interface as `any`, and the
+ * two obvious companions to it are measured DEAD LEVERS, recorded here so the
+ * next session does not re-derive them:
+ *
+ * - an anonymous `{}` (empty, no signatures, no index, excluding fresh object
+ *   literals, which share the identical type and are real values whose shape
+ *   the object-bag and collection censuses discover): the three.js app's unmet
+ *   obligations went 33 UP to 34 and `boxed` 17190 -> 17568. `{}` is the
+ *   checker's answer for a great many things that are not "unstated" at all --
+ *   an intersection reduced to nothing, a mapped type over no keys, a bag
+ *   before its census runs -- and boxing all of them costs more pairings than
+ *   it closes.
+ * - the lowercase `object` KEYWORD (`TypeFlags.NonPrimitive`), which really is
+ *   one unambiguous spelling and really does state nothing: exactly NEUTRAL on
+ *   unmet obligations (33 -> 33) at `boxed` +103. A cost with no return.
+ *
+ * Both remain correct as statements about what those types SAY. Neither is
+ * worth what it costs as a carrier decision.
+ */
+export declare const isGlobalObjectInterface: (checker: ts.TypeChecker, anchor: ts.Node, type: ts.Type) => boolean;
+/**
+ * Whether `type` is the standard library's `ObjectConstructor` interface --
+ * the type the global `Object` VALUE has, as opposed to `isGlobalObjectInterface`'s
+ * `Object` INSTANCE interface immediately above.
+ *
+ * Exported so the two call sites that ask "is this call really `Object.assign`
+ * on the real global" (`flow/value-flow.ts`'s `isGlobalObjectAssign`,
+ * `object-bag-bindings.ts`'s `isGlobalObjectAssignCall`) ask one shared
+ * question instead of two byte-for-byte-identical copies of it, each
+ * comparing `checker.getTypeAtLocation(callee.expression).getSymbol()?.getName()`
+ * against the literal string `'ObjectConstructor'`.
+ */
+export declare const isGlobalObjectConstructor: (checker: ts.TypeChecker, anchor: ts.Node, type: ts.Type) => boolean;
+/** The standard global Function constructor value, by ambient declaration identity. */
+export declare const isGlobalFunctionConstructor: (checker: ts.TypeChecker, anchor: ts.Node, type: ts.Type) => boolean;
+/** The standard global Array constructor value, by ambient declaration identity. */
+export declare const isGlobalArrayConstructor: (checker: ts.TypeChecker, anchor: ts.Node, type: ts.Type) => boolean;
+/** A standard global namespace value, resolved by symbol identity rather than spelling. */
+export declare const isStandardGlobalValue: (checker: ts.TypeChecker, expression: ts.Expression, name: string) => boolean;
+/**
+ * The target type of an authenticated `Object.assign` call with at least one source.
+ *
+ * The ambient signature's `T & U` result describes which properties source
+ * code may read after the copy. The runtime value is still `T`: ECMA-262
+ * mutates and returns the first argument. Every binding census has to read
+ * that identity the same way, or one census publishes the intersection while
+ * the invocation producer publishes the target and creates a conversion
+ * between two carriers for one object. The extra keys live in the native
+ * target's dynamic-property sidecar; changing the value's carrier is neither
+ * necessary nor correct.
+ *
+ * A primitive target is excluded because Object.assign first boxes it, and
+ * this backend does not implement wrapper-object carriers.
+ */
+export declare const objectAssignTargetType: (checker: ts.TypeChecker, node: ts.Node) => ts.Type | null;
+/**
+ * The object `Object.assign( {}, ...sources )` builds, when `literal` is that
+ * bare `{}`.
+ *
+ * `objectAssignTargetType`'s identity argument holds for a target that exists
+ * before the call: the value returned IS that object, so its carrier is that
+ * object's own, extra keys in the sidecar. A bare empty literal written in the
+ * target position has no carrier of its own to keep. It is allocated for this
+ * call, observed nowhere else, and the one statement anywhere of what it holds
+ * afterwards is the call's own `T & U` -- which the checker has already
+ * reduced, dropping the empty member (`{} & Record<string, number[]>` reports
+ * as `Record<string, number[]>`). Publishing the literal's own `{}` in its
+ * place put an empty record on one side of the copy and a dictionary on the
+ * other: three's `Object.assign( {}, source.defines )` then refused for want of
+ * a record<-dictionary arm, and no such arm can exist, since an empty struct
+ * has nowhere to put a key.
+ *
+ * Read by BOTH the call's result (`objectAssignTargetType`) and the literal's
+ * own layout (`structural-layout-type.ts`), so the target and the value it
+ * becomes are one carrier by construction. A literal with properties keeps its
+ * own shape -- it states one -- and so does a literal under an assertion.
+ */
+export declare const objectAssignFreshTargetType: (checker: ts.TypeChecker, literal: ts.ObjectLiteralExpression) => ts.Type | null;
+/**
+ * `type` with every vacuous member dropped, or `null` when nothing is left.
+ *
+ * `annotationStatesNothing` answers "is this type ENTIRELY a non-statement",
+ * which is the right question for evidence: a type that says nothing must not
+ * become the answer. It is the wrong question for a JOIN with a vacuous
+ * member ALONGSIDE a real one -- `{} | E['Bindings'] | undefined`, the first
+ * element of the tuple TypeScript gives hono's `fetch(request, ...rest)`.
+ * That type is not entirely vacuous (the indexed access is a statement), yet
+ * the `{}` inside it still makes EVERY object type assignable to the whole,
+ * so a `widestOf` join hands it back as "the" type and the other elements --
+ * `ExecutionContext` -- vanish without a trace.
+ *
+ * The caller's use is a re-test, never an answer: strip the vacuous parts and
+ * ask whether the coverage survives. If it does, the join was real; if it
+ * does not, the coverage was `{}`'s alone and the join has to state the union
+ * instead. Nothing published to representation is ever the stripped type --
+ * that would be the opposite error, narrowing a slot below what the program
+ * annotated.
+ */
+export declare const withoutVacuousMembers: (checker: ts.TypeChecker, anchor: ts.Node | null, type: ts.Type) => ts.Type | null;
+export declare const annotationStatesNothing: (checker: ts.TypeChecker, anchor: ts.Node, type: ts.Type) => boolean;
+/**
+ * The exact type of an EMPTY object literal the program wrote as a value --
+ * `{}` in `const { fn = function () {} } = {}` -- or `null` for any other node.
+ *
+ * `annotationStatesNothing` above is right to treat the vacuous type `{}` as
+ * a non-statement when it arrives as an ANNOTATION or as a join member: every
+ * type is assignable to it, so it dominates. The same type on a literal the
+ * program EVALUATES is the opposite: a fresh object with exactly zero members,
+ * the most precise statement there is, and the one a destructuring pattern
+ * reads out of. Filtering it out there left every pattern over `{}` with no
+ * holder at all, so each leaf fell back to the checker's own `any` (the JS
+ * checker's answer for a key the literal lacks) and boxed the default it was
+ * meant to bind. A literal with spreads or properties is not this case: the
+ * ordinary literal type is already non-vacuous and needs no exception.
+ */
+export declare const exactEmptyObjectLiteralType: (checker: ts.TypeChecker, node: ts.Node) => ts.Type | null;
+/**
+ * Whether a stated type has an unstated position ANYWHERE inside it, and so
+ * could be an upper bound rather than the last word.
+ *
+ * A pre-filter, not a judgement: `narrowsOnlyUnstatedPositions` below decides
+ * whether a particular value may narrow a particular statement. This only
+ * keeps a census from carrying every annotated declaration in the program as
+ * a candidate when almost none of them state nothing anywhere.
+ */
+export declare const containsUnstatedPosition: (checker: ts.TypeChecker, anchor: ts.Node, declared: ts.Type, depth?: number) => boolean;
+/**
+ * WHETHER A STATED TYPE AND THE TYPE THAT ACTUALLY FLOWS INTO IT DIFFER ONLY
+ * WHERE THE STATEMENT SAID NOTHING.
+ *
+ * `annotationStatesNothing` is all-or-nothing about one annotation, which is
+ * the right question for a parameter written `: {}` and the wrong one for
+ * hono's `matchResult: Result<[unknown, RouterRoute]>`. That annotation states
+ * plenty -- a two-armed union of tuples of arrays of tuples -- and states
+ * NOTHING at exactly one leaf, the `unknown` where the handler goes. The
+ * program's only writer hands it `Result<[H, RouterRoute]>`, identical
+ * everywhere the annotation spoke and concrete at the one place it did not.
+ *
+ * Reading the annotation as the last word there is what forces a value that is
+ * already exactly right to be rebuilt into a boxed copy of itself -- through
+ * two arrays and three records, which is not a conversion any backend can
+ * render soundly (an array rebuild is a COPY, and a copy is not the array the
+ * caller passed). Reading it as an upper bound instead, satisfied at every
+ * position it constrains, is what lets the value stay itself.
+ *
+ * This is deliberately NOT "the actual type is assignable to the declared
+ * one". Assignability admits a narrowing at a position the program DID state
+ * -- `x: string | number` fed only strings -- and honoring the statement is
+ * this compiler's rule everywhere else. `checker.isTypeAssignableTo` is still
+ * required (the caller asks it), but it is the floor, not the test.
+ */
+export declare const narrowsOnlyUnstatedPositions: (checker: ts.TypeChecker, anchor: ts.Node, declared: ts.Type, actual: ts.Type, depth?: number) => boolean;
+/**
+ * `T | undefined` -> `T`, and ONLY the `undefined` member: a `null` member is
+ * a different absence value and stays.
+ *
+ * Needed where a cell's contents and a READ of that cell disagree about an
+ * absence the language already resolved -- a DEFAULTED parameter, whose slot
+ * carries `undefined` (that is what the default exists to answer) and whose
+ * body binding cannot: `producers/bindings.ts`'s `contributeDefaultedParameter`
+ * strips it there from the compiler's own type table, and this is the same
+ * strip asked of a `ts.Type`, for the censuses that answer a body read.
+ *
+ * `getNonNullableType` is the wrong instrument -- it strips `null` too, and
+ * `p: T | null = null` is ordinary TypeScript whose body really does observe
+ * the `null`.
+ */
+export declare const withoutUndefinedMember: (checker: ts.TypeChecker, type: ts.Type) => ts.Type;
+/** Whether `a` and `b` are the constructor objects of two different classes -- nominally distinct, whatever their shapes. */
+export declare const isDistinctClassConstructorPair: (a: ts.Type, b: ts.Type) => boolean;
+/** Shape subtyping cannot discard the identity of a class constructor selected at runtime. */
+export declare const nominalConstructorChoiceTypeAt: (checker: ts.TypeChecker, node: ts.Node, read: (operand: ts.Expression) => ts.Type) => ts.Type | null;
+export declare const widestOf: (checker: ts.TypeChecker, types: readonly ts.Type[]) => ts.Type | null;
+/**
+ * The array carrier selected by the normalizing idiom
+ *
+ *     Array.isArray(values[i]) ? values[i] : [values[i]]
+ *     Array.isArray(data) ? data : [data]
+ *
+ * or `null` when the expression does not prove that one carrier.
+ *
+ * A binding census can know more about `values[i]` than TypeScript's checker
+ * does. Three's `UniformsGroup.copy` is the measured case: the census has
+ * `Uniform | Uniform[]`, while the JSDoc-backed array literal still has
+ * `Uniform[]`. The generic conditional join sees `Uniform | Uniform[]` and
+ * republishes that union, losing the fact the condition just established;
+ * the subsequent numeric read then correctly refuses a union whose scalar arm
+ * is not indexable.
+ *
+ * The rule is tied to the real global `Array.isArray`, to a repeated stable
+ * PURE READ -- a bare identifier, or one slot of one proven native Array --
+ * and to a one-element alternate containing that same read. The IDENTIFIER
+ * form is what a one-or-many parameter is normally written over -- hono's
+ * `node-server` websocket bridge is `const datas = Array.isArray(data) ?
+ * data : [data]` over `data: WebSocketData` -- and without it the join
+ * republished the whole union, so the `for (const data of datas)` that
+ * follows read an element off a carrier whose scalar arms are not indexable
+ * at all. Every array arm already discovered for the slot must fit the
+ * alternate's array type. Thus the answer is the carrier both reachable arms
+ * share; this does not turn a general predicate or a mutable/accessor read
+ * into a narrowing.
+ */
+export declare const normalizedArrayConditionalType: (checker: ts.TypeChecker, node: ts.ConditionalExpression, read: (operand: ts.Expression) => ts.Type | null) => ts.Type | null;
+/**
+ * The type an `arg is any[]` predicate REALLY establishes, when the checker
+ * answered with the intersection it falls back to.
+ *
+ * `Array.isArray`'s `lib.es5.d.ts` signature is `isArray(arg: any): arg is
+ * any[]`, and TypeScript narrows a union by a predicate by KEEPING the
+ * constituents assignable to the predicate's type. Where none is, it does not
+ * answer `never` -- it answers the INTERSECTION `T & any[]`, distributed over
+ * `T`'s arms, and every read through it is typed `any`:
+ *
+ *     Array.isArray(value) ? value[0] : value          // value: string
+ *     Array.isArray(pattern) ? pattern[0] : p          // readonly [...] | '*'
+ *
+ * (`@hono/node-server`'s `createUpgradeRequest` and hono's trie router; a
+ * `readonly` tuple is not assignable to the mutable `any[]` either, so the
+ * fallback fires for a type that IS an array.) That `any` is an artifact of a
+ * failed narrowing, not a boundary the program declared: the value is a
+ * `std::string` or a fixed tuple and the read has a stated answer either way.
+ * Carried as `dynamic` it reached the backend as a result with no absence
+ * materialization, and boxing the read to make it compile is the shortcut this
+ * compiler does not take.
+ *
+ * `any[]` states no carrier at all (`isUnusableEvidence`), so intersecting
+ * with it adds nothing physical; what it adds is the assertion that the value
+ * is an array HERE. So the answer is the array/tuple constituents of the rest
+ * -- and with none of those the predicate is statically false for a value that
+ * has a carrier, the arm is dead, and the honest type is the one the value
+ * already had. Only a SINGLE surviving subject is answered: two array arms
+ * would need a join this is not the place to take.
+ */
+export declare const arrayPredicateNarrowedTypeOf: (checker: ts.TypeChecker, type: ts.Type) => ts.Type | null;
+/**
+ * The element an `x[k]` read produces when the checker typed it `any` only
+ * because `x` is standing in an `arg is any[]` narrowing's intersection.
+ *
+ * The key is answered off the narrowed subject exactly as any other read is:
+ * a literal key names a member (a tuple's `[0]` is its first element type,
+ * not the join of all of them), and anything else takes the receiver's own
+ * index signature -- `String`'s is `readonly [index: number]: string`, which
+ * is the carrier `stringIndexText`'s `charAt` already renders.
+ */
+export declare const arrayPredicateNarrowedElementTypeOf: (checker: ts.TypeChecker, node: ts.ElementAccessExpression) => ts.Type | null;
+/**
+ * `node`'s own type, derived from its immediate operands via `read`.
+ *
+ * Handles exactly the composite shapes described in this file's header
+ * comment, and nothing else: this is a LEAF function, not a walker -- it
+ * asks `read` for each operand's type and combines the answers by the
+ * operator's own fixed rule, doing no traversal of its own beyond that one
+ * level. Every caller supplies its own `read` (its `known ?? resolve`), so
+ * this function's own recursion depth is always exactly one.
+ */
+export declare const derivedExpressionType: (checker: ts.TypeChecker, node: ts.Expression, read: (operand: ts.Expression) => ts.Type | null) => ts.Type | null;
+export declare const isNullishType: (type: ts.Type) => boolean;
+/**
+ * The join of a WRITE SET -- every value the program stores into one storage
+ * location -- once the two things `widestOf` reads as a disagreement but
+ * which are not one have been accounted for; or `null` when the writes
+ * genuinely do not agree.
+ *
+ * `widestOf` answers FIRST and unchanged, so every location bound today binds
+ * to exactly the same type; only a set it has already refused reaches the
+ * rest of this.
+ *
+ * ## A nullish write states ABSENCE, not a rival type
+ *
+ * `widestOf` asks whether one OBSERVED type covers every other, and under
+ * `strictNullChecks` no object type covers `null`. So the single commonest
+ * shape a write-set census exists for -- `let currentProgram = null;` filled
+ * in later with a real value and set back to `null` on teardown, or
+ * `this.view = null` in a constructor and a real object in a setter --
+ * refuses, attributed `writes-disagree`: the join read the location's own
+ * emptiness as a type competing for the slot. It is not one. Storage that is
+ * sometimes empty and otherwise holds `T` is exactly `T | null` -- the
+ * `optional(T, null)` carrier this compiler already has, not a union of its
+ * own making. Every constituent is still a type the program itself wrote.
+ *
+ * `getNullableType` is the checker's own constructor for that union, the
+ * same one `return-bindings.ts` uses for a `Map.get` result and
+ * `parameter-slot.ts` for a defaulted parameter, and it flattens -- so a
+ * write already typed `T | null` re-joins to `T | null` rather than nesting.
+ *
+ * The observed nullish FLAGS are carried through rather than fixed: writes
+ * holding `null` yield `T | null`, `undefined` yields `T | undefined`, both
+ * yield both. Answering `null` where the program only ever wrote `undefined`
+ * (or the reverse) would be inventing an inhabitant no census here may
+ * invent. And a set that is ENTIRELY nullish is left to `widestOf`, which
+ * already answers it on its own.
+ *
+ * ## A literal FORM is not a disagreement either
+ *
+ * The other shape is storage whose every write is a different LITERAL of one
+ * primitive: `let type;` in three's `WebGLAttributes.js` is written `5126`,
+ * `5131`, `5123`, `5122`, `5125`, `5124`, `5120`, `5121` -- eight writes,
+ * eight literal types, none covering another, refused. The storage question
+ * has an answer nobody has to invent: `number`. It is TypeScript's own
+ * answer too -- a `let` initialized with `5126` is widened to `number` by
+ * the language's mutable-binding rule, and the literal type survives here
+ * only because these censuses read the RIGHT-HAND SIDE expression rather
+ * than the declaration. `widenLiteral` above states the same rule for the
+ * same reason (`"a" + "b"` is `string`, not the literal `"ab"` nobody
+ * wrote). Tried only after the unwidened join has refused, so storage whose
+ * writes DO agree on a literal keeps it.
+ *
+ * ## Why this is shared rather than copied
+ *
+ * `local-bindings.ts` (a `let`/`var` cell) and `field-bindings.ts` (a class
+ * field) ask the identical question of two different declaration kinds, and
+ * a field written `null` in the constructor and filled in later is the same
+ * shape as the cell this landed for. Two copies of a join rule is the
+ * "two authorities" defect this compiler keeps paying for -- the same
+ * reasoning that made `annotationStatesNothing` shared. One rule, one file,
+ * asked by both.
+ */
+export declare const joinOfWrites: (checker: ts.TypeChecker, types: readonly ts.Type[]) => ts.Type | null;
+/**
+ * A member with no evidence at all -- vetoes the whole set (see
+ * `disjointArmsOf`). Deliberately wider than `isUnusableEvidence` above:
+ * `unknown` is a genuine dynamic boundary here too, not merely a case that
+ * other join rules leave alone.
+ *
+ * Exported for `parameter-bindings.ts`'s `restElementTypeAt`: a rest
+ * parameter's own binding can be REASSIGNED in the body (`params =
+ * enhanceLogMessage(params)`), and that write is evidence about the SAME
+ * cell the call-site tail is joined into -- an `Array<any>`-returning
+ * reassignment is exactly the "genuine dynamic boundary" this test already
+ * names, not a second question needing its own copy of the flag set.
+ */
+export declare const carriesNoEvidence: (type: ts.Type) => boolean;
+/**
+ * The DISTINCT, pairwise-disjoint members of `types` -- every one a real
+ * type, none of them subsuming another -- or `null` when the set cannot
+ * safely become one union.
+ *
+ * `joinOfWrites` above answers "is there ONE type every write agrees on".
+ * This is the question that only gets asked once that has already failed:
+ * is the DISAGREEMENT ITSELF the answer? `A | B | C`, where `A`, `B`, `C` are
+ * exactly the types the program's own write sites used, is not a guess when
+ * every one of them is real and none of them overlaps another -- it is
+ * precisely what the program does. This compiler's `tagged-union`
+ * representation (`representation/model.ts`) exists for it.
+ *
+ * Two members overlap when either is assignable to the other -- the SAME
+ * `checker.isTypeAssignableTo` `widestOf`'s own `agree` reads a single
+ * covering candidate from above, applied PAIRWISE instead of one-to-all.
+ * Assignable in one direction only is a subsumption (a literal `5` inside
+ * `number`, or one record type's fields a strict subset of another's) --
+ * accepting it would let a value that is honestly a `B` also match arm `A`,
+ * which is a mis-selection, not a conservative one, so the WHOLE set
+ * refuses rather than dropping the overlapping member. Assignable both ways
+ * is the same member spelled twice (two structurally-identical types, or
+ * two references to one declaration) and collapses to one arm silently,
+ * the same reduction `representation/union.ts`'s own `canonicalMembersOf`
+ * performs one layer down. Neither direction is exactly ECMAScript's own
+ * "no runtime value can satisfy both", which is the fact a tagged union's
+ * arms need to be told apart at all -- see that file's own module comment.
+ *
+ * A member that states no evidence at all (`any`/`unknown`/`void`/`never`)
+ * vetoes the whole set outright: unioning a real type with "nothing was
+ * declared" would launder the missing statement as if it were one more arm,
+ * and `void`/`never` are refusals about the STORAGE, not values competing
+ * for the slot.
+ *
+ * Cardinality is not missing evidence. Preserve every admitted member of a
+ * finite write set; representation planning owns its storage and dispatch
+ * costs. An earlier four-arm cutoff erased complete five-way inputs and
+ * made downstream forwarding indistinguishable from an unknown caller.
+ */
+export declare const disjointArmsOf: (checker: ts.TypeChecker, types: readonly ts.Type[]) => readonly ts.Type[] | null;
+/**
+ * The full member list for a SYNTHESIZED union carrier, once `joinOfWrites`
+ * has already refused -- every present (non-nullish) write partitioned the
+ * identical way `joinOfWrites` partitions them, checked for disjointness via
+ * `disjointArmsOf`, with the observed absence values (`null`/`undefined`)
+ * carried through UNCHANGED as members rather than folded into a flag here.
+ *
+ * That last point is deliberate, not an oversight: this function answers a
+ * STRUCTURAL question ("what are this union's members"), not a `ts.Type`
+ * one -- `ts.TypeChecker.getUnionType` is not on the public surface (see
+ * `absent-globals.ts` and `producers/bindings.ts`'s own comments on the same
+ * wall), so unlike `joinOfWrites` this cannot hand back one `ts.Type` a
+ * caller re-derives structurally. It hands back the member LIST instead, for
+ * a caller that is about to `table.intern({ kind: 'union', members:
+ * list.map(typeOf) })` directly -- and `representation/union.ts`'s own
+ * `deriveUnion` already partitions absent members from present ones and
+ * wraps the result in `optional` exactly as `joinOfWrites` would have, so
+ * passing the nullish members through as ordinary list entries here, rather
+ * than pre-collapsing them, is asking that ONE authority to do it once
+ * instead of a second copy of the same partition living here too.
+ */
+export declare const disjointUnionMembersOf: (checker: ts.TypeChecker, types: readonly ts.Type[]) => readonly ts.Type[] | null;
+/**
+ * `disjointUnionMembersOf`, answered as ONE `ts.Type` -- for a census whose
+ * contract is a `ts.Type` and whose every consumer reads one.
+ *
+ * `collection-bindings.ts`'s array-element census is that census: every
+ * sibling write-set census (a `let` cell, a class field, a parameter, a
+ * return) already answers a disagreeing write set as a disjoint tagged union
+ * through its own `unionArmsAt` channel, while the array census asked
+ * `joinOfWrites` alone and REFUSED the same disagreement
+ * (`array:elements-disagree`). `var xs = []; xs.push(1); xs.push('a')` is the
+ * shape: the array's storage fell to the box, and every `push` boxed its
+ * argument on the way in, for a program that declared nothing dynamic.
+ *
+ * Two things make the `ts.Type` form the right one here rather than a fourth
+ * arms channel. The census's array answers travel through `arrayElementAt`/
+ * `arrayElementForRead`/`arrayElementForOwner` into three other censuses that
+ * read a `ts.Type` (`local-bindings.ts`, `return-bindings.ts`,
+ * `field-bindings.ts`), so a list would leave every one of them answering the
+ * checker's `any` for a union the storage already carries. And the checker's
+ * OWN evolving-array machinery settles the SAME array to the SAME union at
+ * every reference it can finalize (`xs.join(...)` after the pushes is `(string
+ * | number)[]` there): TypeScript widens each pushed value off its literal form
+ * (`addEvolvingArrayElementType`, `getBaseTypeOfLiteralType`) and unions the
+ * results. Building the union through the checker from the identically
+ * widened members yields the IDENTICAL `ts.Type` object (verified: `built ===
+ * settled` for `[number, string, boolean]`), so the storage the census types,
+ * the reads the checker settled, and the `push` slots
+ * (`structural.ts`'s `evolvingArrayMemberTypeAt`) intern to one structural
+ * type with no conversion between them. An arms list interned separately
+ * could not promise that.
+ *
+ * Widening is therefore part of the rule, not a convenience: unwidened, `1`
+ * and `"a"` are two disjoint LITERAL arms, and a storage of `1 | "a"` would be
+ * a second authority beside the checker's `string | number` at every settled
+ * read. `disjointUnionMembersOf`'s own soundness test (no member subsumes
+ * another) is applied unchanged to the
+ * widened members, so a set the cell census would refuse is refused here too.
+ *
+ * Built through the checker's internal `getUnionType`, the same guarded reach
+ * `withoutUndefinedMember` above and `field-bindings.ts`'s `withNullish` make;
+ * a checker without it answers `null`, which is the refusal the caller already
+ * handles.
+ */
+export declare const disjointUnionTypeOf: (checker: ts.TypeChecker, types: readonly ts.Type[]) => ts.Type | null;
+/**
+ * The parts of `parameter-bindings.ts` that answer one question --
+ * "what value does this reference of a named function's identifier stand
+ * for" -- without touching that module's own fixpoint state. Moved here so
+ * `parameter-bindings.ts` has room, under the architecture gate, for the
+ * value-flow evidence this module also builds: `indexNamedCallables` and
+ * `indexAliasEvidence`, below.
+ */
+/** Whether this declaration is one of the five function-like shapes the parameter-binding census tracks. */
+export declare const isTrackedCallable: (node: ts.Node) => node is ts.SignatureDeclaration;
+/**
+ * The real callee and the arguments that actually reach it, once an explicit-
+ * `this` wrapper -- `.call( thisArg, ...args )` or `.apply( thisArg, [ ...
+ * args ] )` -- is unwrapped, or `null` when this call is neither.
+ *
+ * `EventDispatcher.dispatchEvent` calls every registered listener as
+ * `array[ i ].call( this, event )`: a call to `array[ i ]`, with ONE argument,
+ * not a call to `Function.prototype.call` with two. Left wrapped, `checker.
+ * getResolvedSignature` resolves `.call`'s own (unrelated) ambient signature
+ * successfully -- it is not `any`, so it never fell through to the fallback
+ * that would have resolved the real callee -- and the call vanished from
+ * every candidate's evidence without a trace: not refused, simply never
+ * counted. `collect` skips recording checker attribution for these and
+ * `attributeCalls`/`agreedArgumentType` read this map instead of the raw
+ * node, so the SAME machinery that already resolves an ordinary call site's
+ * callee and arguments does the resolving here too, just against `callee`
+ * and `args` rather than `call.expression` and `call.arguments`.
+ *
+ * `.apply` is unwrapped only when its argument list is a literal array with
+ * no spread (`.apply( this, [ a, b ] )`) -- anything else (a spread, a
+ * variable holding the array) stays wrapped rather than guessed at, exactly
+ * the same "refuse rather than invent" rule this module uses everywhere
+ * else.
+ *
+ * The RECEIVER -- `call.expression.expression`, `array[ i ]` above -- must
+ * itself be a FUNCTION VALUE before any of this fires. `.call`/`.apply` are
+ * ordinary member names, and a program is free to declare its own object with
+ * a `.call( ... )` or `.apply( ... )` method (a Command/Strategy pattern, a
+ * Callable-shaped API): unwrapping THAT receiver would silently replace its
+ * real callee and arguments with wrong ones, from a name match with no
+ * relationship to `Function.prototype.call`/`.apply` at all. The receiver's
+ * own static type having at least one CALL SIGNATURE is what makes it
+ * actually a function value -- the same fact `parameter-bindings.ts`'s
+ * `isUnannotated` reads off a `Function`-typed parameter, asked here of the
+ * `.call`/`.apply` receiver instead.
+ */
+export declare const unwrapExplicitThisCall: (checker: ts.TypeChecker, call: ts.CallExpression) => ExplicitThisCallFrame | null;
+/** The actual operand frame of a source call, with authenticated `.call`/`.apply` wrappers erased.
+ *
+ * `pendingExplicitThisAt` is the round-over-round counterpart of
+ * `unwrapExplicitThisCall`'s own static gate: that gate needs the receiver's
+ * CHECKER type to already carry a call signature, which an untyped JS array
+ * element never does -- `EventDispatcher.dispatchEvent`'s `array[ i ].call(
+ * this, event )` types `array[ i ]` as `any` even with a `@param {Function}`
+ * JSDoc tag on the pushing `addEventListener`, because the field the array
+ * lives on (`this._listeners`) itself carries no type. Unwrapping THAT
+ * receiver unconditionally would be unsound (a program's own `.call`-shaped
+ * Command/Strategy object would be silently misread as `Function.prototype.
+ * call`), so the census this resolver comes from proves the array's whole
+ * write history is CLOSED to real function values first (`callableArrayTargetsOf`
+ * in `parameter-bindings.ts`, the identical flow proof `callable-reach.ts`'s
+ * own target resolution trusts) and supplies a reading only once that holds --
+ * never guessed, and absent (round one, and every caller with no census yet)
+ * this stays byte-identical to the always-unresolved answer it replaced. */
+export declare const invocationOperandsOf: (checker: ts.TypeChecker, call: ts.CallExpression | ts.NewExpression, pendingExplicitThisAt?: (call: ts.CallExpression) => ExplicitThisCallFrame | null) => FlowInvocationOperands;
+/** Whether an identifier stands in the callee position of this call. */
+export declare const isCalleeOf: (node: ts.Node, call: ts.CallExpression | ts.NewExpression) => boolean;
+/**
+ * The symbol that names this function's value, or `null` when nothing does.
+ *
+ * A function is enumerable exactly when the program refers to it by a name,
+ * because a name is what a reference can be counted against. Three forms of
+ * name exist and all three are ordinary: a declaration's own (`function f(){}`),
+ * the variable a function expression initializes (`const f = function(){}`),
+ * and the member a method declares (`{ f() {} }`, `class { f() {} }`). A
+ * function expression written directly as an argument has no name at all, and
+ * refusing it is right: its only caller is the function it was passed to, which
+ * is precisely the caller this census cannot enumerate.
+ */
+export declare const nameOfCallable: (declaration: ts.SignatureDeclaration) => ts.MemberName | null;
+/**
+ * Whether a reference to a function's name is one that keeps it enumerable.
+ *
+ * An import or export specifier re-binds the name in another module's scope
+ * without letting anything hold the function as a value, and a declaration's
+ * own name is not a reference to it. A shorthand property in a returned object
+ * (`return { has, init, get }`) is the idiom three's factories are built on:
+ * the function is reachable only as a member of that record, so every call to
+ * it is a member call this census resolves once the record has a type -- which
+ * is what the fixpoint is for.
+ *
+ * Two more shapes are binding-only for the identical reason, one level of
+ * indirection removed -- see `indexAliasEvidence` for the evidence that makes
+ * each of them SOUND rather than merely silent:
+ *
+ * - a bare `return f;`: the SELECTOR-RETURN idiom (`getSingularSetter(type)`
+ *   returning one of several named setters from a switch). The function is
+ *   reachable only by calling whatever the selector returns, and
+ *   `indexAliasEvidence.returnedFrom` records exactly which functions a given
+ *   selector declaration can return, so a call through its result becomes
+ *   real evidence for every one of them.
+ * - `<propertyAccess> = f`: the MEMBER-PUBLICATION idiom (`this.setValue =
+ *   setValueV3f`), the same idea `nameOfCallable` already handles for a
+ *   function declared directly in that position, extended to a function
+ *   merely REFERENCED there. `indexAliasEvidence.publishedUnderMember` keys
+ *   on the checker's own symbol for the member, never its spelling, so a
+ *   later call through an unrelated member that happens to share a name
+ *   never matches.
+ *
+ * A fourth shape needs no alias evidence at all, because it carries no value
+ * flow to begin with: a class named in a HERITAGE CLAUSE (`class Sub extends
+ * Base`, `class Sub implements Base`). `ExpressionWithTypeArguments` is the
+ * node TypeScript uses for exactly these two positions and nowhere else, so
+ * a reference whose direct parent is one names the class being extended or
+ * implemented -- it does not hand the class's constructor to anything. The
+ * two ways a heritage mention could matter for a constructor's own
+ * enumerability are both already real `NewExpression`/`CallExpression` nodes
+ * this census's own `attributeCalls` visits and attributes through
+ * `checker.getResolvedSignature`, independent of the heritage reference
+ * itself: a `super(...)` call in a declared derived constructor resolves
+ * straight to the base constructor's declaration, and `new Derived(...)`
+ * where `Derived` declares no constructor of its own resolves to that same
+ * base declaration too (TypeScript gives the derived class the base's own
+ * construct signature when it has none -- measured directly against this
+ * compiler's own checker: `new Derived(...)`'s resolved signature IS the
+ * base constructor node, and a declared `super(...)` resolves to it too).
+ * Counting the heritage mention as a further escape does not add evidence
+ * the walk lacks -- it double-refuses a constructor whose real callers are
+ * already enumerated elsewhere.
+ *
+ * Everything else -- an argument, a bare variable initializer, a return of
+ * the bare name wrapped in a way that isn't a plain `ReturnStatement` -- hands
+ * the function to a caller this census cannot see, and stays an escape.
+ */
+export declare const isBindingOnlyReference: (node: ts.MemberName) => boolean;
+/**
+ * Every tracked callable declaration in the program, keyed by the symbol
+ * `nameOfCallable` resolves for it -- built once, over EVERY declaration
+ * (not only the census's own unannotated-parameter candidates), because a
+ * selector can return, or a constructor can publish, a callable whose own
+ * parameters are fully typed and irrelevant to this census except as the
+ * far end of an alias chain leading to one that is not.
+ */
+export declare const indexNamedCallables: (checker: ts.TypeChecker, files: readonly ts.SourceFile[], reachable: ProgramReachability) => ReadonlyMap<ts.Symbol, ts.SignatureDeclaration>;
+/**
+ * The two shapes of alias VALUE FLOW this module makes sound: a function
+ * published under a member, and a function bare-returned from a selector.
+ * Both maps are keyed by a real checker symbol or a real declaration --
+ * never by a name string, which is how a member on one class could
+ * otherwise be confused with a same-spelled member on an unrelated one.
+ *
+ * Neither map depends on `parameter-bindings.ts`'s own fixpoint: which
+ * functions get BOUND changes round to round, but which functions are
+ * PUBLISHED where is a fact about the program's syntax and its symbols, settled
+ * once the checker exists. Building this once, outside the round loop, is
+ * sound for the same reason `overridesOfBaseMethod` there is built once.
+ */
+export interface AliasEvidence {
+    /**
+     * Function declarations published under a resolvable member symbol.
+     * `this.setValue = setValueV3f` (and `_this.shadowMap = shadowMap`, and
+     * every other `<propertyAccess> = <name>` assignment) records the
+     * checker's own symbol for `setValue` mapping to `setValueV3f`'s
+     * declaration. Multiple functions can publish under the SAME symbol --
+     * a switch inside one constructor assigning different setters to
+     * `this.setValue` in different branches -- and every one of them is kept:
+     * each receives the evidence a later call attributes, and if their
+     * existing evidence then disagrees, the ordinary `call-sites-disagree`
+     * refusal fires, same as any other conflicting evidence.
+     */
+    readonly publishedUnderMember: ReadonlyMap<ts.Symbol, ReadonlySet<ts.SignatureDeclaration>>;
+    /**
+     * Function declarations bare-returned from a selector, keyed by the
+     * selector's OWN declaration. `getSingularSetter`'s switch returning
+     * `setValueV1f`/`setValueV2f`/`setValueV3f`/`setValueV4f` across its
+     * cases records all four against `getSingularSetter`'s declaration.
+     */
+    readonly returnedFrom: ReadonlyMap<ts.SignatureDeclaration, ReadonlySet<ts.SignatureDeclaration>>;
+}
+export declare const emptyAliasEvidence: AliasEvidence;
+export declare const indexAliasEvidence: (checker: ts.TypeChecker, files: readonly ts.SourceFile[], reachable: ProgramReachability, namedCallables: ReadonlyMap<ts.Symbol, ts.SignatureDeclaration>) => AliasEvidence;
+/**
+ * The type a node holds according to every authority in the program, checker
+ * included.
+ *
+ * The binding census answers `null` for "nothing here improves on the
+ * checker's answer", which is the safe default for the census but a trap for
+ * its readers: it makes consulting the census OPTIONAL. A consumer that simply
+ * calls `checker.getTypeAtLocation` gets a plausible type, no error, and no
+ * indication that a better answer already existed one call away. That is not a
+ * hypothetical -- it is the single most common defect this compiler has had.
+ * `signatureOf` asked the census for a signature's parameters and not its
+ * result; `memberOf` had the census threaded into its own module and never
+ * called it; the array-element consumer asked only about `never` and not
+ * `any`. Each was a few lines, each cost hundreds of boxed carriers, and each
+ * looked locally correct.
+ *
+ * So the rule is: a consumer asks THIS, not the checker. The checker is an
+ * input to the census, not an alternative to it, and the fallback belongs in
+ * one place rather than being rewritten -- or forgotten -- at every call site.
+ *
+ * A site that genuinely wants the checker's own answer wants a different
+ * question than this one ("what did the program STATE here", for a stated
+ * annotation, versus "what does this hold"), and should say so in its own
+ * words at the call rather than reaching past this by habit.
+ */
+export declare const censusedTypeAt: (checker: ts.TypeChecker, census: {
+    readonly typeAt: (node: ts.Node) => ts.Type | null;
+}, node: ts.Node) => ts.Type;
+/**
+ * The synthesized-union arms a write-set census resolved for a cell, answered
+ * at the DECLARATION and at every READ of it alike.
+ *
+ * A cell whose writes disagree DISJOINTLY resolves to a union rather than a
+ * refusal (see `disjointUnionMembersOf`), and that answer has to travel as an
+ * arm LIST because `ts.TypeChecker.getUnionType` is not public -- so it cannot
+ * ride in a census's `typeAt`, and each census publishes it through a second
+ * channel, `unionArmsAt`, for `structural.ts` to intern.
+ *
+ * Every one of those channels was written as `ts.isParameter(node) ? arms.get(
+ * node) : null` (and the variable/field equivalents), which answers for the
+ * declaration NODE and for nothing else. That is the two-authorities defect
+ * this compiler keeps rediscovering, in its quietest possible form: the
+ * declaration got the union, and every ordinary reference to the cell -- an
+ * identifier one line down -- fell through to the checker's own `any` and
+ * boxed. Nothing reported a disagreement, because the second authority
+ * answered `null`, and `null` is exactly how a census says "the checker's
+ * answer stands".
+ *
+ * Measured on the three.js app: **176 top-level `dynamic` carriers sat on identifiers
+ * reading a parameter the census had already resolved** -- 104 + 57 + 15,
+ * the three synthesized-union parameters in the renderer's object walks, to
+ * the unit. Answering here instead swapped exactly 171 `dynamic` carriers for
+ * 171 `tagged-union` ones (a carrier kind the same program already selected
+ * 2040 times), with `ops` unchanged and 92 FEWER unmet obligations.
+ *
+ * No flow narrowing is discarded by answering at a read, which is the one
+ * thing that could make this unsound and the reason a census's `typeAt` needs
+ * an equality guard for its ordinary bindings: a synthesized union arises only
+ * where the declaration's own checker type is `any`, and `any` carries no
+ * narrowing for a reference to report differently.
+ *
+ * `declarations.length === 1` is the same soleness test every resolver in this
+ * module applies -- a name with two declarations is two cells, and answering
+ * for either would be picking one.
+ */
+export declare const synthesizedUnionArmsAt: <D extends ts.Declaration>(checker: ts.TypeChecker, node: ts.Node, arms: ReadonlyMap<D, readonly ts.Type[]>, owns?: (declaration: ts.Declaration) => declaration is D) => readonly ts.Type[] | null;