gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/scope-resolution/resolution-outcome.d.ts

@@ -1,5 +1,18 @@
-import type { Range } from '../../../_shared/index.js';
-export type ResolutionSuppressionReason = 'adl-ordinary-lookup-blocked' | 'conversion-rank-tied' | 'inline-ns-ambiguous' | 'member-lookup-ambiguous' | 'selected-callable-deleted' | 'overload-ambiguous' | 'overload-ambiguous-normalization' | 'free-call-instance-ownership';
+import type { Range, ReferenceKind } from '../../../_shared/index.js';
+import type { DecodedReceiverChain } from '../utils/receiver-chain-codec.js';
+export type ResolutionSuppressionReason = 'adl-ordinary-lookup-blocked' | 'conversion-rank-tied' | 'inline-ns-ambiguous' | 'member-lookup-ambiguous' | 'selected-callable-deleted' | 'overload-ambiguous' | 'overload-ambiguous-normalization' | 'free-call-instance-ownership'
+/** #2701 — the receiver is rebound by its own scope and has no type
+ *  there (a JS/TS ordinary `function`'s `this`), so no enclosing type
+ *  can be its type. See `isReceiverOwnedButUnbound`. */
+ | 'receiver-owned-but-unbound'
+/** #2744 — the receiver is a compound expression (a call, a chain, a
+ *  construction) whose TYPE could not be established, so the member call
+ *  was dropped with no candidate at all. Distinct from the ambiguity
+ *  reasons above: there is nothing to be ambiguous between. Consumers use
+ *  this to report `impact()`/`context()` counts as a lower bound rather
+ *  than as exact, since a dropped site's callee is by definition unknown
+ *  and cannot be attributed to any target. */
+ | 'receiver-unresolved';
 export type ResolutionOutcome = {
     readonly kind: 'resolved';
     readonly targetId: string;
@@ -20,5 +33,102 @@ export type ResolutionOutcome = {
     readonly filePath: string;
     readonly name: string;
     readonly range: Range;
+    /**
+     * The reference kind of the site the suppression happened at, when the
+     * emitting case knows it.
+     *
+     * Set for `receiver-unresolved` because Case 0's gate fires on any
+     * compound receiver regardless of what the reference *is*, so a property
+     * write (`x.argtypes = [...]`) and a property read (`d.source.kind`) land
+     * in the same bucket as a genuinely dropped method call. Anything
+     * measuring resolver gaps has to separate them, and the site kind is the
+     * only authoritative signal — re-deriving it from the source line means
+     * regex-classifying the number that gates the work, which is the same
+     * textual-shape dispatch the structural-receiver work exists to remove.
+     *
+     * Diagnostic only. `summarizeUnresolvedReceivers` ignores it, so the
+     * persisted `RepoMeta.unresolvedReceiverMembers` artifact is unchanged.
+     */
+    readonly siteKind?: ReferenceKind;
+    /**
+     * Structural shape of the receiver whose type could not be established.
+     *
+     * Derived from the site's ENCODED RECEIVER CHAIN — the compact string the
+     * capture emitters mint by walking the real AST — never from the source
+     * line. Re-deriving a shape textually would mean regex-classifying the
+     * number that gates this work, which is exactly the textual-shape dispatch
+     * the structural-receiver line of work exists to remove.
+     *
+     * Lets a consumer ask "which KIND of receiver are we losing?" instead of
+     * only "how many". Without it, `callDropsByExtension` is the finest
+     * available split and a language's bucket says nothing about whether the
+     * cause is one defect or five.
+     *
+     * NOTE ON COVERAGE: only drops that REACH the recorder carry a shape, and
+     * Case 0's gate fires on receiver punctuation, so shapes that mint no
+     * reference site at all (`?.`, explicit type args, subscript) are absent
+     * from this breakdown entirely — they are the INVISIBLE-GAP population the
+     * bench shape arm exists to see. A shape census here is a census of the
+     * VISIBLE drops, not of all lost calls.
+     *
+     * Diagnostic only. `summarizeUnresolvedReceivers` ignores it, so the
+     * persisted `RepoMeta.unresolvedReceiverMembers` artifact is unchanged.
+     */
+    readonly receiverShape?: ReceiverShape;
+    /**
+     * Whether the receiver is rooted INSIDE the analyzed program.
+     *
+     * The single most important distinction a static-analysis tool can make
+     * about a call it did not resolve, and the one this codebase previously
+     * collapsed:
+     *
+     * - `in-program` — the receiver's base is a local, parameter, field or a
+     *   type this index knows. Failing to type it is a RESOLVER DEFECT: a real
+     *   caller exists in the graph and was lost.
+     * - `external` — the base is rooted in code this index does not contain
+     *   (`System.out.println`, `fetch(...)`, `os.environ.setdefault`). There is
+     *   NO node to point an edge at, so nothing was lost. A compiler resolves
+     *   these against the JDK / BCL / lib.d.ts; without those, the honest
+     *   answer is "outside the program", not "unknown".
+     *
+     * Only `in-program` makes an `impact` count a lower bound. Reporting an
+     * external target as uncertainty is what made the hedge fire on nearly
+     * every real codebase and taught readers to ignore it.
+     */
+    readonly receiverOrigin?: ReceiverOrigin;
 };
+/**
+ * How a dropped receiver was spelled, structurally.
+ *
+ * - `chain-call`   every recorded step is a call — `svc.getUser().save()`
+ * - `chain-field`  every recorded step is a field — `h.repo.save()`
+ * - `chain-mixed`  the chain interleaves both — `svc.getUser().addr.save()`
+ * - `chain-unwrap` the chain contains an `await` or `index` step — the shapes
+ *                  this work exists to expose. They were previously counted as
+ *                  FIELDS, because the classifier's parameter widened `kind` to
+ *                  `string` and they fell into its `else`.
+ * - `no-chain`     the site carried no chain, so the receiver was a compound
+ *                  expression the capture walk could not reduce to a nameable
+ *                  base (it stopped early, or the base was unencodable)
+ */
+export type ReceiverShape = 'chain-call' | 'chain-field' | 'chain-mixed' | 'chain-unwrap' | 'no-chain';
+/**
+ * Is the receiver rooted inside the analyzed program, or outside it?
+ *
+ * `unknown` is for a site carrying no usable base at all — neither a chain nor
+ * an explicit receiver — where the question cannot be asked. It is treated as
+ * `in-program` for hedging purposes, because assuming completeness we cannot
+ * demonstrate is the unsafe direction.
+ */
+export type ReceiverOrigin = 'in-program' | 'external' | 'unknown';
+/** Classify a dropped receiver from its encoded chain. `undefined` chain ⇒
+ *  `no-chain`; an undecodable one is also `no-chain`, since what we know about
+ *  it is exactly that no usable structure survived.
+ *
+ *  Takes `DecodedReceiverChain` rather than a structural duck-type: widening
+ *  `kind` to `string` let `await` and `index` fall into an `else` branch and be
+ *  counted as FIELDS, so the two shapes this work exists to expose were
+ *  censused as `chain-field`. The discriminated union makes a new step kind a
+ *  compile error instead of a silent bucket. */
+export declare function classifyReceiverShape(decoded: DecodedReceiverChain | undefined): ReceiverShape;
 export type ResolutionOutcomeRecorder = (outcome: ResolutionOutcome) => void;

package/dist/core/ingestion/scope-resolution/resolution-outcome.js

@@ -1 +1,38 @@
-export {};
+/** Classify a dropped receiver from its encoded chain. `undefined` chain ⇒
+ *  `no-chain`; an undecodable one is also `no-chain`, since what we know about
+ *  it is exactly that no usable structure survived.
+ *
+ *  Takes `DecodedReceiverChain` rather than a structural duck-type: widening
+ *  `kind` to `string` let `await` and `index` fall into an `else` branch and be
+ *  counted as FIELDS, so the two shapes this work exists to expose were
+ *  censused as `chain-field`. The discriminated union makes a new step kind a
+ *  compile error instead of a silent bucket. */
+export function classifyReceiverShape(decoded) {
+    if (decoded === undefined || decoded.steps.length === 0)
+        return 'no-chain';
+    let calls = 0;
+    let fields = 0;
+    let unwraps = 0;
+    for (const step of decoded.steps) {
+        switch (step.kind) {
+            case 'call':
+                calls++;
+                break;
+            case 'field':
+                fields++;
+                break;
+            case 'await':
+            case 'index':
+                unwraps++;
+                break;
+        }
+    }
+    // An unwrap step dominates: a chain containing one fails for reasons a pure
+    // field or call chain does not, so folding it into either bucket would
+    // misattribute the population a fix has to target.
+    if (unwraps > 0)
+        return 'chain-unwrap';
+    if (calls > 0 && fields > 0)
+        return 'chain-mixed';
+    return calls > 0 ? 'chain-call' : 'chain-field';
+}

package/dist/core/ingestion/scope-resolution/scope/namespace-targets.d.ts

@@ -15,8 +15,19 @@
  *
  * Next-consumer contract: any language with namespace-style imports
  * (TypeScript `import * as X`, Java static import, Ruby `require`)
- * uses this directly. `ParsedImport.kind === 'namespace'` is the
- * cross-language hook.
+ * uses this directly. The finalized `ImportEdge.kind === 'namespace'`
+ * classification is authoritative; providers may produce it directly from
+ * syntax or reclassify a named import after target resolution proves it names
+ * a module.
+ *
+ * A namespace edge may be reachable under TWO receiver spellings: the name it
+ * binds locally, and — for a language that opts in via
+ * `ScopeResolver.namespaceReceiverIncludesImportPath` — the dotted module path
+ * it was imported under (#2826). Python's `import a.b` binds only `a` while
+ * the call site writes `a.b`, so both keys are needed. The opt-in exists
+ * because the edge shape alone cannot tell that case from Swift's
+ * `import Foo.Bar`, where the same pair means the opposite thing — see the
+ * hook's contract note.
  *
  * Scope-chain concern (verified 2026-04-21): `pythonImportOwningScope`
  * documents that function-local and class-body imports bind to the
@@ -33,4 +44,15 @@
  */
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
-export declare function collectNamespaceTargets(parsed: ParsedFile, scopes: ScopeResolutionIndexes): Map<string, string[]>;
+import type { ScopeResolver } from '../contract/scope-resolver.js';
+export interface NamespaceTargetOptions {
+    /** `ScopeResolver.namespaceReceiverPaths` for the file's language. Absent
+     *  (or returning `undefined` per edge) keeps the local-name-only default:
+     *  the extra spellings are opt-in, never inferred from the edge shape. */
+    readonly receiverPaths?: ScopeResolver['namespaceReceiverPaths'];
+    /** Whether a path is a module the workspace parsed. Lets a provider propose
+     *  a prefix file and have it dropped when absent, instead of minting a key
+     *  to a file that does not exist. Defaults to "nothing exists". */
+    readonly moduleFileExists?: (filePath: string) => boolean;
+}
+export declare function collectNamespaceTargets(parsed: ParsedFile, scopes: ScopeResolutionIndexes, options?: NamespaceTargetOptions): Map<string, string[]>;

package/dist/core/ingestion/scope-resolution/scope/namespace-targets.js

@@ -15,8 +15,19 @@
  *
  * Next-consumer contract: any language with namespace-style imports
  * (TypeScript `import * as X`, Java static import, Ruby `require`)
- * uses this directly. `ParsedImport.kind === 'namespace'` is the
- * cross-language hook.
+ * uses this directly. The finalized `ImportEdge.kind === 'namespace'`
+ * classification is authoritative; providers may produce it directly from
+ * syntax or reclassify a named import after target resolution proves it names
+ * a module.
+ *
+ * A namespace edge may be reachable under TWO receiver spellings: the name it
+ * binds locally, and — for a language that opts in via
+ * `ScopeResolver.namespaceReceiverIncludesImportPath` — the dotted module path
+ * it was imported under (#2826). Python's `import a.b` binds only `a` while
+ * the call site writes `a.b`, so both keys are needed. The opt-in exists
+ * because the edge shape alone cannot tell that case from Swift's
+ * `import Foo.Bar`, where the same pair means the opposite thing — see the
+ * hook's contract note.
  *
  * Scope-chain concern (verified 2026-04-21): `pythonImportOwningScope`
  * documents that function-local and class-body imports bind to the
@@ -31,28 +42,37 @@
  * honor the hook's per-scope contract, this function must walk the
  * reference-site scope chain (mirror `findExportedDefByName`).
  */
-export function collectNamespaceTargets(parsed, scopes) {
+export function collectNamespaceTargets(parsed, scopes, options) {
     const out = new Map();
     const moduleEdges = scopes.imports.get(parsed.moduleScope);
     if (moduleEdges === undefined)
         return out;
-    const namespaceLocals = new Set();
-    for (const imp of parsed.parsedImports) {
-        if (imp.kind === 'namespace')
-            namespaceLocals.add(imp.localName);
-    }
+    const addTarget = (key, targetFile) => {
+        let targets = out.get(key);
+        if (targets === undefined) {
+            targets = [];
+            out.set(key, targets);
+        }
+        if (!targets.includes(targetFile))
+            targets.push(targetFile);
+    };
+    const moduleFileExists = options?.moduleFileExists ?? (() => false);
     for (const edge of moduleEdges) {
-        if (edge.targetFile === null)
+        if (edge.targetFile === null || edge.kind !== 'namespace')
             continue;
-        if (!namespaceLocals.has(edge.localName))
+        const spellings = options?.receiverPaths?.({
+            localName: edge.localName,
+            importPath: edge.targetExportedName,
+            targetFile: edge.targetFile,
+        }, moduleFileExists);
+        // A provider that declines this edge — or has no hook — gets the default:
+        // the bound name alone, pointing at this edge's own target.
+        if (spellings === undefined) {
+            addTarget(edge.localName, edge.targetFile);
             continue;
-        let targets = out.get(edge.localName);
-        if (targets === undefined) {
-            targets = [];
-            out.set(edge.localName, targets);
         }
-        if (!targets.includes(edge.targetFile))
-            targets.push(edge.targetFile);
+        for (const [spelling, targetFile] of spellings)
+            addTarget(spelling, targetFile);
     }
     return out;
 }

package/dist/core/ingestion/scope-resolution/scope/walkers.d.ts

@@ -22,7 +22,7 @@
 import type { BindingRef, ParsedFile, ScopeId, SymbolDefinition, TypeRef } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import type { SemanticModel } from '../../model/semantic-model.js';
-import type { WorkspaceResolutionIndex } from '../workspace-index.js';
+import type { WorkspaceResolutionIndex } from '../workspace-index-types.js';
 /**
  * Look up binding refs at `scopeId` for `name`, consulting both the
  * finalize-owned `bindings` channel and the post-finalize
@@ -75,11 +75,99 @@ export declare function namesAtScope(scopeId: ScopeId, scopes: ScopeResolutionIn
  * parsed output.
  */
 export declare function isClassLike(t: string): boolean;
+/**
+ * Does this label declare MEMBERS addressable by name?
+ *
+ * `isClassLike` answers two questions that only coincide for classes:
+ *   1. does this declare members I can look up?  — a SHAPE (structural)
+ *   2. does this participate in inheritance / MRO? — a NOMINAL TYPE
+ *
+ * A TypeScript object-type alias answers YES to (1) and emphatically NO to
+ * (2): it declares the same `property_signature` members as the interface
+ * beside it, but has no supertypes and no place in a linearization. Answering
+ * (2) "yes" merely to buy (1) is what widening `isClassLike` would do, and it
+ * would enrol every language's aliases (Rust `type_item`, Kotlin/Swift/Dart
+ * typealias, C `typedef`) into MRO and heritage.
+ *
+ * So the two questions get two predicates. Use THIS one where the question is
+ * "find the shape so I can look up a member"; keep `isClassLike` where the
+ * question is inheritance. The call sites announce which they are:
+ * `resolveInheritanceBaseInScope` and `resolveQualifiedInheritanceBase` are
+ * (2); receiver typing is (1).
+ *
+ * NOT YET INCLUDED, deliberately: `Typedef` and `Union`. They belong here
+ * conceptually — the `union_item` note on `MEMBER_OWNER_NODE_TYPES` records
+ * the same gap, that a union owns fields captured as `Property` yet is not a
+ * recognized owner — but neither is wired as a member container today, so
+ * adding them would widen a predicate nothing exercises. They join when their
+ * containers do, with fixtures.
+ */
+export declare function isShapeLike(t: string): boolean;
 /**
  * Walk the scope chain from `startScope` looking for a typeBinding
  * named `receiverName`. Returns the TypeRef or undefined if no binding
  * exists in the chain.
+ *
+ * A scope that declares `ownsReceivers.has(receiverName)` terminates the
+ * walk with `undefined` (#2701): it binds that receiver itself, so an
+ * enclosing scope's binding is not visible through it. The check runs
+ * AFTER this scope's own `typeBindings`, so a scope that both owns and
+ * binds the receiver — a class method, which is where `this` is bound TO
+ * the class — still resolves normally. The namespace/global fallbacks
+ * below are also skipped: they answer "which type is named X", which is a
+ * different question from "what is this scope's receiver", and reaching
+ * them for an owned-but-unbound receiver is how a static method or a
+ * detached callback acquires a fabricated one.
+ */
+/**
+ * True when `receiverName` is DEFINITIVELY unresolvable at `startScope`:
+ * a scope on the chain declares it owns that receiver (`Scope.ownsReceivers`)
+ * and carries no type binding for it (#2701).
+ *
+ * This is a stronger statement than `findReceiverTypeBinding` returning
+ * `undefined`, which only means "no type found" — an ordinary miss that later
+ * passes are free to resolve by other means. Here the language has said the
+ * receiver is REBOUND at this scope, so no enclosing type can be its type:
+ * `this.m()` inside a nested JS/TS `function` is a call on whatever the
+ * function is invoked with, which the graph does not model. A member call
+ * whose receiver is unresolvable in this sense must be suppressed rather
+ * than left to the receiver-blind lexical fallback in `lookupCore`, which
+ * would find the enclosing class's member by name alone.
+ *
+ * Returns false for every language that leaves `ownsReceivers` unset.
  */
+export declare function isReceiverOwnedButUnbound(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): boolean;
+/**
+ * True when a declaration between the call site and its module scope shadows a
+ * file-level namespace import of the same name. Namespace targets are collected
+ * per FILE, so every consumer of that map must apply this lexical guard before
+ * trusting it at an inner scope — otherwise `def f(pkg): pkg.db.query()`
+ * resolves through the import that the parameter shadows, producing a wrong
+ * edge rather than a missing one.
+ *
+ * A namespace key may itself be a dotted import path (`pkg.db`, #2826), but the
+ * name a declaration can shadow is always the ROOT identifier — `pkg = Decoy()`
+ * shadows `pkg.db` too. Testing the whole dotted string would never match a
+ * binding, so the guard would silently stop guarding for exactly the keys it
+ * was extended to cover. Single-segment names are unaffected: their root is
+ * themselves.
+ *
+ * Fails closed (returns `true`) on a missing scope or a parent cycle: for every
+ * caller, suppressing a resolution costs a missing edge, while trusting a
+ * corrupt scope chain costs a wrong one.
+ *
+ * Reads `scope.bindings` DIRECTLY rather than through `lookupBindingsAt`, and
+ * that is deliberate — the opposite of the fix #2745 applied to Rust's
+ * `headBoundLocally`. There the question was "is this name bound at all?", so
+ * missing the finalized/augmented import channels lost real bindings. Here the
+ * question is "does something LOCAL shadow the import?", and the import's own
+ * finalized binding is the one thing that must NOT count: routing this through
+ * `lookupBindingsAt` would find the namespace import shadowing itself and
+ * suppress every namespace receiver in the workspace. Locals, parameters and
+ * lexical names all live in the scope's own tables, which is exactly the set
+ * this walk wants.
+ */
+export declare function isNamespaceNameShadowed(namespaceName: string, inScope: ScopeId, scopes: ScopeResolutionIndexes): boolean;
 export declare function findReceiverTypeBinding(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): TypeRef | undefined;
 /**
  * Resolve a typeBinding for `name` from the per-namespace channel
@@ -113,7 +201,103 @@ export declare function moduleScopeIdOf(startScope: ScopeId, scopes: ScopeResolu
  *
  * Without (2) we'd miss every cross-file class-receiver call.
  */
-export declare function findClassBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+/**
+ * Every class-like definition visible for `name`, from the scope chain AND the
+ * qualified-name index, deduped by `nodeId`.
+ *
+ * Exists because `walkScopeChain` returns the FIRST match and cannot report a
+ * collision, so a caller that widens what a name can match (the decoration
+ * normalizer below) has no way to tell "one answer" from "picked the nearest of
+ * several". Mirrors `findAllCallableBindingsInScope`, which solved the same
+ * problem for callables.
+ */
+export declare function findAllClassBindingsInScope(startScope: ScopeId, name: string, scopes: ScopeResolutionIndexes): readonly SymbolDefinition[];
+/**
+ * Strip one layer of type-preserving decoration off a declared type name, or
+ * `undefined` when there is nothing left to strip. Supplied per language through
+ * the `ScopeResolver` contract; the core never names a language (AGENTS.md R6).
+ *
+ * TYPE-PRESERVING only — pointer, reference, `const`, nullable, borrow,
+ * deref-transparent smart pointer, sigil. A CONTAINER (array, slice, map,
+ * `Option`) changes the member set, so stripping one here would type
+ * `repos: Repo[]` as `Repo` and let `repos.find(x)` fold to `Repo.find`. Those
+ * are unwrapped only by an index step that consumed a subscript.
+ */
+export type DecorationStripper = (typeName: string) => string | undefined;
+/**
+ * Does the scope chain at `scopeId` bind `name` as a declared TYPE PARAMETER?
+ *
+ * The question a class-binding lookup has to ask before it answers, because a
+ * type parameter and a class are spelled identically and only the declaration
+ * says which one a name is. `class Box<T> { t: T }` beside a workspace
+ * `export class T` resolved `t` to the CLASS and emitted a confident wrong edge
+ * from every member call on `t` — the exact failure mode this subsystem treats
+ * as worse than a missing edge.
+ *
+ * WHY LEXICAL GROUNDING CANNOT SUBSTITUTE. The erasure grounds in
+ * `resolveErasedBaseName` all ask "can the file SEE a declaration by this
+ * name", and here it plainly can: `export class T` is imported, bound, and
+ * lexically visible. Visibility is not the defect — the name means something
+ * else at this site regardless of what else is visible, and only the enclosing
+ * declaration's parameter list records that. Measured: with the grounding rule
+ * in place the false edge still emitted.
+ *
+ * ABSENCE IS NOT EVIDENCE. `typeParameters` is populated only by the languages
+ * whose captures were extended for it, and is absent both for a non-generic
+ * declaration and for every declaration in a language that does not populate it
+ * yet. So only a POSITIVE match declines; an absent list changes nothing, which
+ * is what keeps every unconverted language behaving exactly as it does today.
+ */
+export declare function bindsTypeParameter(scopeId: ScopeId, name: string, scopes: ScopeResolutionIndexes): boolean;
+export declare function findClassBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes, 
+/**
+ * OPT-IN. When supplied, a name that binds nothing is retried with decoration
+ * stripped one layer at a time, and each retry must resolve to exactly ONE
+ * class-like definition or it declines.
+ *
+ * Opt-in rather than global because roughly two dozen call sites use the shape
+ * `findClassBindingInScope(...) ?? otherResolver(...)`: turning a former
+ * `undefined` into a hit SUPPRESSES the fallback that used to answer, which
+ * would retarget inheritance edges and bypass generic-specialization
+ * selection. Only receiver-chain base and step resolution passes this.
+ */
+stripDecoration?: DecorationStripper): SymbolDefinition | undefined;
+/**
+ * Resolve a class-like binding for a declared type name, tolerating a spelling
+ * that carries TYPE ARGUMENTS (`Repo<User>`, `Vec<int>`) where the declaration
+ * itself is registered under the bare base name.
+ *
+ * Two normalizations, and they are not the same thing:
+ *
+ *   1. DECORATION stripping (`stripDecoration`, opt-in — see the parameter).
+ *      Peels type-PRESERVING wrappers (`*T`, `const T&`) off the name.
+ *   2. Type-argument ERASURE (unconditional, and the wider of the two).
+ *      `Repo<User>` → `Repo`. This is what actually widens what binds, because
+ *      it makes one declaration answer for EVERY instantiation of it — right
+ *      for a language where a generic class has a single declaration, and a
+ *      hazard where it does not, which is why the exact-argument match runs
+ *      first and why the base-name route below refuses to return a
+ *      declaration that pinned its own arguments.
+ *
+ * Order: exact spelling → exact type-argument match (lexically visible
+ * candidates first, workspace-wide index second) → base name.
+ */
+export declare function resolveClassBindingForName(scopeId: string, rawClassName: string, scopes: ScopeResolutionIndexes, 
+/**
+ * OPT-IN, and it governs (1) only — argument erasure happens either way.
+ * `findClassBindingInScope`'s own docstring explains the opt-in: a name that
+ * previously bound nothing starts binding, which SUPPRESSES the
+ * `?? otherResolver(...)` fallbacks several callers rely on.
+ *
+ * THE RULE, not a roll-call of who currently passes it (that list has been
+ * appended to once per round of this work and is stale the moment it is
+ * written): pass it from a receiver-TYPING site, and only where the site
+ * already forwarded the same `stripTypePreservingDecoration` to the bare
+ * lookup — so a Go pointer receiver keeps resolving exactly as it did. A site
+ * that has never stripped must keep calling without it, because starting to
+ * strip is what suppresses its fallback.
+ */
+stripDecoration?: DecorationStripper): SymbolDefinition | undefined;
 /**
  * Resolve a class-like inheritance target using the shared inheritance
  * resolution chain. Keeps pre-emitted heritage edges and language-specific
@@ -178,6 +362,17 @@ export declare function isOwnableValueLabel(t: string): boolean;
  * predicate differs.
  */
 export declare function findValueBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+/**
+ * Look up a SHAPE binding (class-like, or an object-type alias) by name.
+ *
+ * Mirrors `findClassBindingInScope` exactly; only the accepted def-type
+ * predicate differs — the same relationship `findValueBindingInScope` has to
+ * it. Exists so a receiver typed as an object-type alias can reach that
+ * alias's members WITHOUT the alias becoming eligible as an inheritance base:
+ * `findClassBindingInScope` is what `resolveInheritanceBaseInScope` calls, so
+ * widening that one would answer a question about hierarchies with a shape.
+ */
+export declare function findShapeBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
 /**
  * Look up a callable (Function/Method/Constructor) by name in the
  * given scope's chain. Uses the dual-source pattern (scope.bindings +
@@ -189,14 +384,18 @@ export declare function findValueBindingInScope(startScope: ScopeId, receiverNam
  * def-type predicate differs.
  */
 export declare function findCallableBindingInScope(startScope: ScopeId, callableName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+export interface CallableBindingCandidate {
+    readonly def: SymbolDefinition;
+    /** Every visibility path for this definition, in binding precedence order. */
+    readonly bindings: readonly BindingRef[];
+}
 /**
- * Look up all callable bindings (Function/Method/Constructor) by name
- * from the nearest scope in the chain that binds `callableName`.
- *
- * Preserves the original scope-walk boundary used by
- * `findCallableBindingInScope`: once any callable binding is found in a
- * scope, outer scopes are not consulted.
+ * Binding-aware callable lookup for consumers that need visibility evidence.
+ * Unlike `lookupBindingsAt`, duplicate definitions retain every binding path,
+ * so a weaker augmentation can contribute provenance even when a finalized
+ * binding remains the candidate's canonical definition.
  */
+export declare function findAllCallableBindingCandidatesInScope(startScope: ScopeId, callableName: string, scopes: ScopeResolutionIndexes): readonly CallableBindingCandidate[];
 export declare function findAllCallableBindingsInScope(startScope: ScopeId, callableName: string, scopes: ScopeResolutionIndexes): readonly SymbolDefinition[];
 /**
  * ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when ordinary
@@ -254,7 +453,9 @@ export declare function populateClassOwnedMembers(parsed: ParsedFile): void;
  * for nested namespaces regardless of whether the inner namespace's name is
  * stored simple or already dotted. Skips defs already carrying the prefix.
  */
-export declare function tagNamespacePrefixes(parsed: ParsedFile): void;
+export declare function tagNamespacePrefixes(parsed: ParsedFile, options?: {
+    readonly qualifiedNamesCarryNamespace?: boolean;
+}): void;
 /**
  * Walk a scope chain upward looking for the innermost enclosing
  * Class scope and return that class's def. Used by per-language