@geastack/compiler 1.0.15

package/dist/semantics/normalize/structural-declared-body.d.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import type { StructuralTypeId } from '../../identity/ids.js';
+import type { StructuralShape } from '../model/structural-types.js';
+import type { StructuralTypeTable } from '../model/structural-type-table.js';
+/**
+ * The structure a declared name stands for.
+ *
+ * A name without a body is a name the later layers cannot lay out, so the body
+ * is interned while the nominal identity is still anchored -- a member that
+ * refers back to the declaration resolves to the anchor instead of re-entering
+ * translation. It lives beside `structural.ts` rather than inside it because
+ * everything it needs is already an argument: the table, the walk, and the two
+ * shape builders.
+ */
+export interface DeclaredBodyParts {
+    readonly table: StructuralTypeTable;
+    readonly typeOf: (type: ts.Type) => StructuralTypeId;
+    readonly signatureOf: (signature: ts.Signature) => import('../model/structural-types.js').SignatureShape;
+    readonly objectShapeOf: (type: ts.Type, location: ts.Node | null, members: 'all' | 'interface' | 'data-only') => StructuralShape;
+    /** The array an interface extending `Array`/`ReadonlyArray` is, with its own fields -- see `structural.ts`. */
+    readonly arrayHeritageShapeOf: (type: ts.Type, location: ts.Node) => StructuralShape | null;
+}
+export declare const createDeclaredBodyResolver: ({ table, typeOf, signatureOf, objectShapeOf, arrayHeritageShapeOf }: DeclaredBodyParts) => {
+    declaredBodyOf: (type: ts.Type, declarationLocation: ts.Node) => StructuralTypeId | null;
+};

package/dist/semantics/normalize/structural-declared-body.js

@@ -0,0 +1,147 @@
+import ts from 'typescript';
+/**
+ * Which type-level function is still gated, by the name it was written under.
+ *
+ * The alias symbol is the only handle on a conditional that means anything to a
+ * reader: the checker's own rendering of an unresolved conditional is the whole
+ * `A extends B ? C : D` text with every argument still open, which is unreadable
+ * once several of them nest, and the refusals aggregate to nothing because each
+ * nesting depth prints differently. `EnhancedOmit` names the defect.
+ */
+const conditionalName = (type) => type.aliasSymbol?.getName() ?? '<anonymous>';
+/**
+ * Whether `type` is the INSTANCE type TypeScript infers for a pre-`class`
+ * JavaScript constructor function -- the "Constructed" type of `function
+ * SourceNode(line) { this.line = line }`, named after the function itself.
+ *
+ * It matters because such a type's members come from two different places and
+ * only one of them is storage. `this.line = line` in the body is a per-instance
+ * field; `SourceNode.prototype.add = function () {}` is a prototype member every
+ * instance merely SEES. The checker already tells them apart -- the first symbol
+ * carries `SymbolFlags.Property`, the second `SymbolFlags.Method` -- which is
+ * exactly the distinction `structural-members.ts`'s `data-only` mode is written
+ * around, and exactly the one a `class` instance already gets. A pre-`class`
+ * constructor and a `class` describe the same object, so one rule has to answer
+ * for both; laying this one out as `all` made every prototype method a struct
+ * field, and nothing ever wrote it (`X.prototype.m = f` lowers to a dynamic set
+ * on the prototype object, not a store into the instance), so the field held a
+ * null callable and calling it segfaulted.
+ *
+ * Recognised from the type's own symbol rather than from `declarationLocation`,
+ * because the symbol of such an instance type carries BOTH the function and the
+ * expando identifiers that assign statics onto it, and which one
+ * `declarationOfSymbol` picks is not this rule's question. The type having no
+ * call or construct signature of its own is already established by the caller --
+ * the function type itself returned a `signature` shape well above here.
+ */
+const isJsConstructorInstanceType = (type) => (type.getSymbol()?.getDeclarations() ?? []).some((declaration) => (ts.isFunctionDeclaration(declaration) || ts.isFunctionExpression(declaration)) && declaration.body !== undefined);
+export const createDeclaredBodyResolver = ({ table, typeOf, signatureOf, objectShapeOf, arrayHeritageShapeOf }) => {
+    const declaredBodyOf = (type, declarationLocation) => {
+        // An interface or type alias has no implementation to be missing: it names
+        // a shape, and a shape is exactly what a layout is. Whether it was written
+        // in a `.ts` or a `.d.ts` changes nothing about that -- what a declaration
+        // file changes is where *values* come from, and that boundary is refused
+        // where it actually is, at the ambient binding that produces the value.
+        // Refusing the type instead left every framework's public record types with
+        // no carrier at all, which is a gap reported in the wrong place.
+        //
+        // Expansion terminates because every cycle in the type graph passes through
+        // a declared name, and `typeOf` anchors that name before walking its
+        // members: `Promise.then` returning a `Promise` resolves to the anchor
+        // already in flight rather than re-entering translation.
+        // A UNION is asked first, before its call signatures. TypeScript answers
+        // `getCallSignatures()` on a union of function types with the signatures of
+        // ALL its arms, which reads here exactly like an overload set -- and an
+        // overload set is a claim that one value has several conventions, which
+        // `sharedAbiOf` (derive.ts) then has to join or refuse. A union is the
+        // opposite claim: several values, each with its own convention, told apart
+        // by the arm. hono's `type H = Handler<...> | MiddlewareHandler<...>`
+        // (`types.ts:90`) is the case -- two arrow types whose return types differ,
+        // refused as "no primitive joining 2 overload signatures" at every site
+        // that holds a handler.
+        //
+        // Only the union. An INTERSECTION of callables really is an overload set
+        // (that is how a `.d.ts` spells one across merged declarations), so it
+        // keeps the signature path below.
+        if (type.isUnion())
+            return table.intern({ kind: 'union', members: type.types.map(typeOf) });
+        const callSignatures = type.getCallSignatures();
+        const constructSignatures = type.getConstructSignatures();
+        if (callSignatures.length > 0 || constructSignatures.length > 0) {
+            return table.intern({
+                kind: 'signature',
+                call: callSignatures.map((one) => signatureOf(one)),
+                construct: constructSignatures.map((one) => signatureOf(one))
+            });
+        }
+        // A method declared in a declaration file is behavior this compiler does not
+        // implement: it belongs to whatever ships the type, so putting it in the
+        // layout would claim a slot nothing fills. Walking one is also what makes
+        // the enumeration diverge -- a generic method's return type is a fresh
+        // instantiation, every instantiation is a fresh anchor, and `Promise.then`
+        // returning a `Promise` of a new parameter never converges. A use of such a
+        // member refuses at the access, which is where the host protocol is actually
+        // missing.
+        const ambient = declarationLocation.getSourceFile().isDeclarationFile;
+        if (type.flags & ts.TypeFlags.Object) {
+            // Before the object enumeration: an interface that extends an Array is
+            // that array, and enumerating it as an object is the defect.
+            const array = arrayHeritageShapeOf(type, declarationLocation);
+            if (array)
+                return table.intern(array);
+            const members = isJsConstructorInstanceType(type) ? 'data-only' : ambient ? 'interface' : 'all';
+            return table.intern(objectShapeOf(type, declarationLocation, members));
+        }
+        // A name for a UNION or an INTERSECTION is a name for a structure that has
+        // no layout of its own, and reporting no body at all for it is not honest
+        // -- it says the declaration is ambient, which is what `derive.ts` then
+        // reports ("is ambient and has no installed host protocol"). hono's
+        // `export type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T,
+        // Params][]]` (`router.ts`) is the case: an ordinary source type alias, 32
+        // mandatory obligations, refused as though nothing had declared it.
+        //
+        // The members are walked here rather than by re-entering `typeOf` on the
+        // alias itself, which would resolve straight back to the anchor this body
+        // belongs to. That is the same walk `translate`'s own union and
+        // intersection branches do, minus their substitution and absorption rules,
+        // which belong to a type reached WITHOUT a declared name: those rules
+        // rewrite the union, and rewriting it under a nominal anchor would make
+        // the name and its body disagree.
+        if (type.isIntersection()) {
+            // The checker's reconciliation of the members rides along; see the
+            // `resolved` field's doc comment in `model/structural-types.ts`.
+            return table.intern({
+                kind: 'intersection',
+                members: type.types.map(typeOf),
+                declaration: null,
+                resolved: table.intern(objectShapeOf(type, declarationLocation, ambient ? 'interface' : 'all'))
+            });
+        }
+        // A CONDITIONAL that never resolved is not an ambient declaration, and
+        // saying so out loud is the whole point of this branch. `null` here is read
+        // downstream as "the compiler did not define this shape, so a host protocol
+        // must carry it" -- which sent every reader of the mongodb probe's compass
+        // toward installing bindings for `EnhancedOmit`, `InferIdType`,
+        // `OptionalUnlessRequiredId`, `AlternativeType`, `IsAny` and lib.es5's own
+        // `Awaited`/`ReturnType`/`Parameters`/`InstanceType`/`ThisParameterType`.
+        // Not one of those wants a binding: they are ordinary type-level functions
+        // the checker evaluates as soon as it is given a concrete argument, and the
+        // argument is still a type parameter. 378 of that probe's 644 mandatory
+        // obligations were this, reported as something else.
+        //
+        // The reason is interned as the BODY rather than returned as `null` so it
+        // reaches `derive.ts` intact; nothing else about a declared name changes.
+        if (type.flags & ts.TypeFlags.Conditional) {
+            return table.intern({
+                kind: 'unresolved',
+                fallback: 'erased-type-expression',
+                reason: `the conditional type ${conditionalName(type)} is still gated on a type parameter (${declarationLocation.getSourceFile().isDeclarationFile ? 'ambient' : 'source'} declaration); monomorphization never filled it`
+            });
+        }
+        // An enum names a set of literal values, not a structure. Reporting `null`
+        // states that honestly; synthesizing an empty object body would claim the
+        // declaration has a layout it does not have.
+        return null;
+    };
+    return { declaredBodyOf };
+};

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

@@ -0,0 +1,56 @@
+import ts from 'typescript';
+import type { IdentityTable, SpecializationPath } from './identities.js';
+import type { InstantiationCensus } from './instantiation.js';
+import type { SpecializationCensus } from './specialization.js';
+/**
+ * What a specialized copy substitutes for a type parameter.
+ *
+ * This is the one place that answers "given this copy of a generic, what is
+ * `T` actually bound to". `structural.ts` asks it from two different branches
+ * -- the `TypeParameter` branch, which substitutes directly, and the union
+ * branch, which must substitute *before* it can decide the union's own shape
+ * (`T | null` with `T` bound to `unknown` is plain `unknown`, because
+ * `unknown` absorbs every other member). Keeping both callers on one lookup is
+ * what stops those two answers from drifting apart.
+ */
+export interface TypeParameterSubstitution {
+    /** What this copy binds a type parameter's declaration to, or `null` when no enclosing copy binds it. */
+    readonly boundByPath: (declaration: ts.Declaration) => ts.Type | null;
+    /**
+     * What binds a type parameter no copy on the path binds: the program-wide
+     * instantiation census first, then the sole copy of a function TYPE that
+     * owns the parameter. Both branches of `structural.ts` and the path
+     * substitution read this one answer, so a cell whose declared type is
+     * `EmitFunction` and a value the census copied for `EmitFunction`'s only
+     * instantiation cannot disagree about what `T` is.
+     */
+    readonly bindingOf: (declaration: ts.Declaration) => ts.Type | null;
+    /**
+     * The non-recursive "what does this copy substitute for this type" answer.
+     * Returns the type unchanged when it is not a type parameter, has no binding
+     * in this copy, or is the polymorphic `this` parameter -- which is never a
+     * real substitution target, since its symbol's declaration is the class
+     * itself rather than a type-parameter declaration.
+     */
+    readonly substituteTypeParameter: (candidate: ts.Type) => ts.Type;
+}
+/**
+ * Searched innermost first: a parameter shadowed by a nested generic's own
+ * parameter of the same declaration cannot happen -- declarations are distinct
+ * objects -- but the innermost binding is still the one in scope, and finding it
+ * first is what makes nesting compose.
+ */
+export declare const createPathBinding: (specializations: SpecializationCensus, path: SpecializationPath) => (declaration: ts.Declaration) => ts.Type | null;
+/**
+ * The substitution one copy performs, stated over a symbol resolver rather than
+ * over the whole `IdentityTable`.
+ *
+ * `identities.ts` needs this same answer while it is still building that table:
+ * a name that reaches a generic reaches the copy its own arguments select, and
+ * the arguments of a site written inside another generic are only concrete once
+ * this substitution has run. One definition is the point -- a second, private
+ * copy of the rule is exactly how two authorities over "what is `T` here" drift
+ * apart.
+ */
+export declare const createPathSubstitution: (declarationOfSymbol: (symbol: ts.Symbol) => ts.Declaration | null, specializations: SpecializationCensus, path: SpecializationPath, fallback?: (declaration: ts.Declaration) => ts.Type | null) => ((candidate: ts.Type) => ts.Type);
+export declare const createTypeParameterSubstitution: (identities: IdentityTable, instantiations: InstantiationCensus, specializations: SpecializationCensus, path: SpecializationPath) => TypeParameterSubstitution;

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

@@ -0,0 +1,120 @@
+import ts from 'typescript';
+/**
+ * Searched innermost first: a parameter shadowed by a nested generic's own
+ * parameter of the same declaration cannot happen -- declarations are distinct
+ * objects -- but the innermost binding is still the one in scope, and finding it
+ * first is what makes nesting compose.
+ */
+export const createPathBinding = (specializations, path) => (declaration) => {
+    for (let index = path.length - 1; index >= 0; index -= 1) {
+        const step = path[index];
+        if (!step)
+            continue;
+        const copy = specializations.specializationsOf(step.owner)[step.ordinal];
+        const bound = copy?.bindingOf(declaration);
+        if (bound)
+            return bound;
+    }
+    return null;
+};
+/**
+ * The substitution one copy performs, stated over a symbol resolver rather than
+ * over the whole `IdentityTable`.
+ *
+ * `identities.ts` needs this same answer while it is still building that table:
+ * a name that reaches a generic reaches the copy its own arguments select, and
+ * the arguments of a site written inside another generic are only concrete once
+ * this substitution has run. One definition is the point -- a second, private
+ * copy of the rule is exactly how two authorities over "what is `T` here" drift
+ * apart.
+ */
+export const createPathSubstitution = (declarationOfSymbol, specializations, path, fallback = () => null) => {
+    const boundByPath = createPathBinding(specializations, path);
+    const filledByPath = (open) => {
+        for (let index = path.length - 1; index >= 0; index -= 1) {
+            const step = path[index];
+            if (!step)
+                continue;
+            const filling = specializations.specializationsOf(step.owner)[step.ordinal]?.fillingOf(open);
+            if (filling)
+                return filling;
+        }
+        return null;
+    };
+    return (candidate) => {
+        // A composite the enclosing copy's own call closed -- `T[]` written at a
+        // site inside `outer<T>`, `string[]` in the copy `outer(words)` minted.
+        // See `Specialization.fillingOf`.
+        if (!(candidate.flags & ts.TypeFlags.TypeParameter)) {
+            return (candidate.flags & (ts.TypeFlags.Object | ts.TypeFlags.UnionOrIntersection)) !== 0
+                ? (filledByPath(candidate) ?? candidate)
+                : candidate;
+        }
+        const symbol = candidate.getSymbol();
+        const declaration = symbol ? declarationOfSymbol(symbol) : null;
+        if (!declaration || ts.isClassLike(declaration))
+            return candidate;
+        const bound = boundByPath(declaration) ?? fallback(declaration);
+        return bound && bound !== candidate ? bound : candidate;
+    };
+};
+/**
+ * A type parameter owned by a function TYPE -- `type EmitFunction = <T extends
+ * Node>(node: T) => void` -- has no body a copy could specialize, so no path
+ * step ever binds it, and the instantiation census cannot bind it either when
+ * every call through the type happens inside another generic (`emitFn(c)` with
+ * `c: Child` records a hole, which that census rightly drops). The
+ * specialization census's fixpoint does fill those holes from the enclosing
+ * copies, so when it minted exactly ONE copy of the function type, that copy's
+ * tuple is the type's only instantiation in the program: the cell declared
+ * with the type holds the value specialized on that tuple (`closeOpenValueUses`
+ * and the fixpoint's `typeOwners` branch key the value use on it), and the
+ * type read at the cell must say the same. Two or more copies fall through to
+ * the constraint, which is what the value use then closes over too.
+ */
+const createSoleTypeCopyBinding = (specializations) => (declaration) => {
+    if (!ts.isTypeParameterDeclaration(declaration))
+        return null;
+    const owner = declaration.parent;
+    if (!(ts.isFunctionTypeNode(owner) ||
+        ts.isConstructorTypeNode(owner) ||
+        ts.isCallSignatureDeclaration(owner) ||
+        ts.isConstructSignatureDeclaration(owner)))
+        return null;
+    // A call/construct signature that is one arm of an OVERLOADED interface
+    // or type literal (`interface Respond { <T,U>(v: T, flag?: U): string;
+    // <T,U>(v: T, init?: U): string }`) owns its own, textually separate `T` --
+    // a distinct declaration per arm even though every arm spells it the same
+    // way. "Exactly one copy" is a fact about ONE arm's own recorded calls,
+    // never about the callable value as a whole: the checker resolves any one
+    // call to exactly one arm, so the arm it picks racks up a copy from that
+    // call's own concrete argument while every sibling arm -- never itself
+    // selected -- sits at zero and falls through to the constraint below. The
+    // two arms then answered `T` differently (the call's own argument shape
+    // versus the bare constraint) for what is one physical calling
+    // convention, and `sharedAbiOf` (representation/derive.ts) read that as
+    // the arms disagreeing at the parameter they in fact agree on --
+    // `generic-field-initializer.ts`'s `Respond`, unjoinable at parameter 0.
+    // A function TYPE's own signature has no siblings (`type EmitFunction =
+    // <T>(...) => void` is the whole type), so this guard is a no-op there:
+    // the sole-copy reasoning stays exactly as documented above for the case
+    // it was built for, and only turns off where a second arm makes "the
+    // type's only instantiation" a claim about one arm rather than the type.
+    const container = owner.parent;
+    if (ts.isInterfaceDeclaration(container) || ts.isTypeLiteralNode(container)) {
+        const siblings = container.members.filter((member) => ts.isCallSignatureDeclaration(owner) ? ts.isCallSignatureDeclaration(member) : ts.isConstructSignatureDeclaration(member));
+        if (siblings.length > 1)
+            return null;
+    }
+    const copies = specializations.specializationsOf(owner);
+    return copies.length === 1 ? (copies[0]?.bindingOf(declaration) ?? null) : null;
+};
+export const createTypeParameterSubstitution = (identities, instantiations, specializations, path) => {
+    const soleTypeCopy = createSoleTypeCopyBinding(specializations);
+    const bindingOf = (declaration) => instantiations.bindingOf(declaration) ?? soleTypeCopy(declaration);
+    return {
+        boundByPath: createPathBinding(specializations, path),
+        bindingOf,
+        substituteTypeParameter: createPathSubstitution(identities.declarationOfSymbol, specializations, path, bindingOf)
+    };
+};

package/dist/semantics/normalize/structural-indexed-access.d.ts

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+/**
+ * The member types `objectType[indexType]` resolves to, or `null` when the
+ * access cannot be resolved from what the object type declares.
+ *
+ * An empty result is `null` too, deliberately: `O[K]` naming no member at all
+ * is not the empty union (which would be `never`, a claim this has no grounds
+ * to make) -- it means the key set and the object type disagreed, and the
+ * caller should keep refusing.
+ */
+export declare const indexedAccessMemberTypes: (checker: ts.TypeChecker, objectType: ts.Type, indexType: ts.Type) => readonly ts.Type[] | null;

package/dist/semantics/normalize/structural-indexed-access.js

@@ -0,0 +1,126 @@
+import ts from 'typescript';
+/**
+ * `T[K]` -- an indexed access the checker left DEFERRED.
+ *
+ * A concrete one never reaches here: `Rec['a']` and `Rec[keyof Rec]` are both
+ * resolved by the checker itself before this layer ever sees them (verified
+ * directly -- they arrive already flagged `Number`/`Union`, never
+ * `IndexedAccess`). What does reach here is the generic form, `S[keyof S]`
+ * written inside a body whose `S` is still a type parameter, and that is
+ * exactly what monomorphization exists to answer: inside the copy that binds
+ * `S` to a real type, `S[keyof S]` is an ordinary union of that type's own
+ * member types.
+ *
+ * The substitution has to be applied by hand because `structural.ts`'s
+ * `TypeParameter` branch only fires when the type IS a parameter. `S[keyof S]`
+ * is an `IndexedAccess` whose *operand* is one, so the substitution never
+ * descended into it and the whole access fell through to
+ * "checker type with flags 8388608 is not modelled" -- one unmodelled form,
+ * reported as hundreds of unrelated-looking unresolved carriers, because a
+ * bottom carrier propagates into every value derived from it.
+ *
+ * Nothing here guesses. Every answer is a member the object type declares, read
+ * out of the checker after the copy's own binding is substituted in; a key this
+ * cannot name resolves to nothing and the caller keeps its honest refusal.
+ */
+/** The keys an index type names against one object type, or `null` when it names something this cannot enumerate. */
+const keysOf = (checker, objectType, indexType) => {
+    const constituents = indexType.isUnion() ? indexType.types : [indexType];
+    const keys = [];
+    for (const constituent of constituents) {
+        // `keyof O` names every property O has. Enumerating them is citing O's own
+        // declaration, not inventing a key set: `getProperties()` is the same list
+        // `keyof` itself is built from.
+        if ((constituent.flags & ts.TypeFlags.Index) !== 0) {
+            keys.push(...objectType.getProperties().map((property) => property.name));
+            continue;
+        }
+        if (constituent.isStringLiteral()) {
+            keys.push(constituent.value);
+            continue;
+        }
+        // `ToPropertyKey(0)` is the key `"0"`, which is how a tuple's own element
+        // is named -- the number literal is a key, not a different kind of access.
+        if (constituent.isNumberLiteral()) {
+            keys.push(String(constituent.value));
+            continue;
+        }
+        // A key this cannot name exactly, but which the CHECKER says is a string,
+        // names the whole key set. `for (const k in o) o[k]` inside a generic is
+        // the case: TypeScript types `k` as `Extract<keyof T, string>`, a
+        // conditional it defers while `T` is open and never reduces afterwards, so
+        // the access had no key set at all -- tsc's `assign` and `copyProperties`,
+        // and every read and write in their loop bodies. The answer is not a guess:
+        // a read through such a key produces one of the object's own members and a
+        // write through it must be accepted by any of them, which is precisely what
+        // the `keyof` arm above already answers. Asked of the checker rather than
+        // matched on a library alias, so a hand-written `T extends string ? T :
+        // never` reaches the same answer as `Extract`.
+        if (checker.isTypeAssignableTo(constituent, checker.getStringType())) {
+            keys.push(...objectType.getProperties().map((property) => property.name));
+            continue;
+        }
+        return null;
+    }
+    return keys;
+};
+/**
+ * The member types `objectType[indexType]` resolves to, or `null` when the
+ * access cannot be resolved from what the object type declares.
+ *
+ * An empty result is `null` too, deliberately: `O[K]` naming no member at all
+ * is not the empty union (which would be `never`, a claim this has no grounds
+ * to make) -- it means the key set and the object type disagreed, and the
+ * caller should keep refusing.
+ */
+export const indexedAccessMemberTypes = (checker, objectType, indexType) => {
+    const keys = keysOf(checker, objectType, indexType);
+    if (keys === null)
+        return null;
+    const members = [];
+    for (const key of keys) {
+        const property = objectType.getProperty(key);
+        if (property) {
+            // STATED, and no node to ask a census about either way: this resolves
+            // `T[K]`'s member types from `objectType`'s own DECLARED shape --
+            // `objectType`/`indexType` are already-resolved `ts.Type`s (see this
+            // module's header), not expression nodes, so there is nothing here a
+            // parameter/return/write-set census (keyed by node) could be consulted
+            // through. `getTypeOfSymbol` is the correct, only question: what does
+            // this member's own declaration say.
+            members.push(checker.getTypeOfSymbol(property));
+            continue;
+        }
+        // A key no named member covers is answered by the object's own index
+        // signature when it has one -- `Counts[string]` over
+        // `interface Counts { [k: string]: number }` is `number`, declared, not
+        // guessed. `getIndexInfosOfType` is asked rather than a key-domain
+        // assumption because an object can carry several.
+        const index = checker.getIndexInfosOfType(objectType)[0];
+        if (index) {
+            members.push(index.type);
+            continue;
+        }
+        // A key an OBJECT type declares no member for is `undefined`, which is the
+        // language's own answer rather than a guess: reading an absent property is
+        // `undefined` in JavaScript, and a key that reached here as a literal came
+        // from the source, so there is nothing left to disagree about. A key
+        // enumerated from `keyof` cannot land here at all -- that list is built
+        // from `getProperties()`, so every one of them resolves above.
+        //
+        // hono is the case this exists for. `class Hono<E extends Env = Env>`'s
+        // body reads `E['Bindings']` throughout, and the copy the program actually
+        // instantiates binds `E` to `BlankEnv`, which is `{}` -- so `Bindings` is
+        // declared by the CONSTRAINT and absent from the ARGUMENT, and the value
+        // really is `undefined` at every one of those reads.
+        //
+        // Only for a real object type. `any`/`unknown` have no members for a
+        // different reason -- nothing is known about them, not that the key is
+        // missing -- and answering `undefined` there would turn "unknown" into a
+        // claim. Those keep the caller's refusal.
+        if ((objectType.flags & ts.TypeFlags.Object) === 0)
+            return null;
+        members.push(checker.getUndefinedType());
+    }
+    return members.length > 0 ? members : null;
+};

package/dist/semantics/normalize/structural-instantiated-member.d.ts

@@ -0,0 +1,64 @@
+import ts from 'typescript';
+import type { SpecializationPath } from './identities.js';
+import type { SpecializationCensus } from './specialization.js';
+/**
+ * What a monomorphized copy's members actually hold, read off the copy's own
+ * instantiated spelling instead of derived by substituting a parameter.
+ *
+ * Substitution rewrites a BARE type parameter and nothing else. That is all it
+ * can do -- the public checker API offers no way to instantiate a type, a gap
+ * `specialization.ts`'s `induceFromHeritage` records for the same reason -- so a
+ * member whose type merely *mentions* a parameter keeps the hole: `filter:
+ * Filter<TSchema>`, `Promise<WithId<TSchema> | null>`, `AlternativeType<WithId<
+ * TSchema>["_id"]>`. Every deferred conditional inside such a type stays
+ * deferred, because a conditional is deferred exactly while its check type is
+ * open, and representation then has no structure to lay out. On the mongodb
+ * CMAP probe that one gap was 312 of 642 mandatory obligations, spread over five
+ * copies of `Collection` whose fillings -- `Document`, `GridFSFile`,
+ * `GridFSChunk`, `any`, `DataKey` -- were all recorded and all available.
+ *
+ * The instantiated spelling closes it without instantiating anything. A copy
+ * minted from a type reference carries the type the checker resolved that
+ * reference to (`Specialization.instantiated`), and reading a member off THAT
+ * hands back the member's type with every conditional already evaluated,
+ * because evaluating them is what instantiating meant. Pairing the
+ * uninstantiated member against the instantiated one then yields a plain
+ * type-to-type table, which is the one thing substitution could not build: an
+ * answer for a composite.
+ *
+ * ## Why pairing by position is exact here
+ *
+ * Both sides come from the SAME symbol -- one read off the generic parent, one
+ * off its instantiation -- so the instantiated member is the image of the
+ * uninstantiated one under a single mapping. Signature `i` corresponds to
+ * signature `i`, parameter `j` to parameter `j`, return to return. This is not
+ * the situation `specialization.ts`'s `unifySignatures` guards against, where a
+ * generic is paired against a concrete type *inferred from a call's arguments*
+ * and nothing orders the two overload sets alike; here the order is the same
+ * list, mapped.
+ *
+ * The counts are still checked at every level and the walk stops on any
+ * mismatch, because instantiation can collapse a shape -- an overload set can
+ * lose a signature to an argument that makes it identical to another, a union
+ * arm can vanish -- and a pairing across a collapse would record an answer for
+ * a type that is not its image.
+ *
+ * ## Why an OVERLOAD's parameters answer for the IMPLEMENTATION's
+ *
+ * `getTypeOfSymbolAtLocation` on an overloaded member publishes the overload
+ * signatures and not the implementation, so the implementation's own parameter
+ * declarations -- which is where `Collection.findOne`'s `filter: Filter<TSchema>
+ * = {}` actually is -- have no instantiated signature of their own to read.
+ * They do not need one. The table is keyed by the OPEN TYPE, and the checker
+ * interns types: the implementation's annotation and the overload's are one
+ * `ts.Type` object whenever they are the same written type, so the entry the
+ * overload records is the entry the implementation looks up. Where the two
+ * annotations genuinely differ they are different objects and no entry is
+ * found, which is the honest answer.
+ */
+export interface InstantiatedMembers {
+    /** The instantiated image of an open type under the copies this view is inside, or `null` when none is known. */
+    readonly through: (type: ts.Type) => ts.Type | null;
+}
+export declare const emptyInstantiatedMembers: InstantiatedMembers;
+export declare const createInstantiatedMembers: (checker: ts.TypeChecker, specializations: SpecializationCensus) => (path: SpecializationPath) => InstantiatedMembers;