gitnexus 1.6.5 → 1.6.6-rc.10

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -22,6 +22,11 @@ import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from
 export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _referenceIndex, handledSites, model, workspaceIndex, options = {}) {
     let emitted = 0;
     const seen = new Set();
+    // Build an O(1) simple-name -> callable defs index over scopes.defs once
+    // per pass so pickUniqueGlobalCallable doesn't re-scan defs.byId.values()
+    // per call site. Same name + callable-kind filter that the previous scan
+    // applied (see pickUniqueGlobalCallable JSDoc). Cost: O(|defs|) once.
+    const globalCallablesBySimpleName = buildGlobalCallableIndex(scopes);
     for (const parsed of parsedFiles) {
         for (const site of parsed.referenceSites) {
             if (site.kind !== 'call')
@@ -45,7 +50,10 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // the same name in a single class, choose the best match by
             // arity + argument types.
             if (fnDef === undefined) {
-                fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model, options.conversionRankFn);
+                fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model, {
+                    conversionRankFn: options.conversionRankFn,
+                    constraintCompatibility: options.constraintCompatibility,
+                });
             }
             // Scope-chain callable lookup. First-match preserves scope-chain
             // precedence (local shadows import). When a conversion-rank function
@@ -63,7 +71,10 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     if (fnDef !== undefined && options.conversionRankFn !== undefined) {
                         const allCallables = findAllCallableBindingsInScope(site.inScope, site.name, scopes);
                         if (allCallables.length > 1) {
-                            const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, options.conversionRankFn);
+                            const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, {
+                                conversionRankFn: options.conversionRankFn,
+                                constraintCompatibility: options.constraintCompatibility,
+                            });
                             if (narrowed.length === 1) {
                                 fnDef = narrowed[0];
                             }
@@ -97,36 +108,49 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             argumentTypes: site.argumentTypes,
                             atRange: { startLine: site.atRange.startLine, startCol: site.atRange.startCol },
                         }, parsed, scopes, parsedFiles);
-                    // When ADL contributed no candidates, narrow ordinary candidates
-                    // with conversion-rank scoring when multiple overloads exist.
-                    // Single candidate or empty falls through to first-match.
+                    const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
                     if (adl === undefined || adl.length === 0) {
-                        if (ordinary.length <= 1 || options.conversionRankFn === undefined) {
+                        // No ADL contribution. Default behavior: `ordinary[0]` —
+                        // scope-chain walk preserves local-shadows-import precedence.
+                        //
+                        // Narrowing kicks in when either disambiguation signal is
+                        // present: any candidate carries `templateConstraints`
+                        // (SFINAE / `requires`-clause guarded templates, #1579), OR
+                        // a conversion-rank function is provided (#1606 / #1578).
+                        // Both hooks are threaded into `narrowOverloadCandidates`
+                        // via the unified `OverloadNarrowingHookCtx`.
+                        const hasConstraints = ordinary.some((d) => d.templateConstraints !== undefined);
+                        const canNarrow = hasConstraints || options.conversionRankFn !== undefined;
+                        if (ordinary.length <= 1 || !canNarrow) {
                             fnDef = ordinary[0];
                         }
                         else {
-                            const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
-                            const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, options.conversionRankFn);
+                            const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, {
+                                conversionRankFn: options.conversionRankFn,
+                                constraintCompatibility: options.constraintCompatibility,
+                            });
                             if (narrowed.length === 1) {
                                 fnDef = narrowed[0];
                             }
-                            else if (narrowed.length > 1) {
-                                // Multiple survivors — suppress when same-file (true
-                                // overloads), mirrors ADL merged-candidate behavior.
+                            else if (narrowed.length === 0) {
+                                handledSites.add(siteKey);
+                                continue;
+                            }
+                            else {
+                                // >1 survivors: same-file → suppress (true overloads,
+                                // "degrade not lie" — no edge beats a wrong one, and
+                                // SFINAE-ambiguous calls land here). Cross-file →
+                                // first-match (shadowing semantics).
                                 const sameFile = narrowed.every((d) => d.filePath === narrowed[0].filePath);
                                 if (sameFile) {
                                     handledSites.add(siteKey);
                                     continue;
                                 }
-                                fnDef = ordinary[0]; // cross-file shadowing → first-match
-                            }
-                            else {
-                                fnDef = ordinary[0]; // narrowed empty → first-match
+                                fnDef = ordinary[0];
                             }
                         }
                     }
                     else {
-                        const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
                         const merged = [];
                         const seenMerge = new Set();
                         const push = (defs) => {
@@ -139,7 +163,10 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         };
                         push(ordinary);
                         push(adl);
-                        const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, options.conversionRankFn);
+                        const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, {
+                            conversionRankFn: options.conversionRankFn,
+                            constraintCompatibility: options.constraintCompatibility,
+                        });
                         if (narrowed.length === 1) {
                             fnDef = narrowed[0];
                         }
@@ -165,7 +192,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // the caller does not import the target package. Same-package calls are
             // usually caught by nearest-scope lookup before reaching here.
             if (fnDef === undefined && options.allowGlobalFallback === true) {
-                fnDef = pickUniqueGlobalCallable(site.name, model, scopes, parsed.filePath, options.isFileLocalDef, site.arity, options.isCallableVisibleFromCaller !== undefined
+                fnDef = pickUniqueGlobalCallable(site.name, model, globalCallablesBySimpleName, parsed.filePath, options.isFileLocalDef, site.arity, options.isCallableVisibleFromCaller !== undefined
                     ? (candidate) => options.isCallableVisibleFromCaller({
                         callerParsed: parsed,
                         candidate,
@@ -205,15 +232,36 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     }
     return emitted;
 }
-function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, conversionRankFn) {
-    const scopeDefs = [];
-    const scopeSeen = new Set();
+/**
+ * Build a `simpleName -> callable defs` index from `scopes.defs` once per
+ * pass. Mirrors the filter the old per-site scan applied: Function /
+ * Method / Constructor, keyed by the last `.`-segment of `qualifiedName`
+ * (falling back to the qualifiedName itself when undotted). Used by
+ * `pickUniqueGlobalCallable` so every free-call fallback site is O(1)
+ * instead of O(|defs|).
+ */
+function buildGlobalCallableIndex(scopes) {
+    const out = new Map();
     for (const def of scopes.defs.byId.values()) {
-        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName;
-        if (simple !== name)
-            continue;
         if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
             continue;
+        const qualified = def.qualifiedName;
+        if (qualified === undefined || qualified.length === 0)
+            continue;
+        const dot = qualified.lastIndexOf('.');
+        const simple = dot === -1 ? qualified : qualified.slice(dot + 1);
+        const bucket = out.get(simple);
+        if (bucket)
+            bucket.push(def);
+        else
+            out.set(simple, [def]);
+    }
+    return out;
+}
+function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, conversionRankFn) {
+    const scopeDefs = [];
+    const scopeSeen = new Set();
+    for (const def of globalCallablesBySimpleName.get(name) ?? []) {
         // Skip file-local defs (e.g. C `static` functions) that live in a
         // different file from the caller — they are logically invisible.
         if (isFileLocalDef !== undefined && def.filePath !== callerFilePath && isFileLocalDef(def)) {
@@ -248,7 +296,9 @@ function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLoc
     // best-rank candidate when exact-type or conversion-rank scoring can
     // disambiguate (e.g., `f(int)` vs `f(double)` called with `f(2.5)`).
     if (scopeDefs.length > 1) {
-        const narrowed = narrowOverloadCandidates(scopeDefs, callArity, callArgTypes, conversionRankFn);
+        const narrowed = narrowOverloadCandidates(scopeDefs, callArity, callArgTypes, {
+            conversionRankFn,
+        });
         if (narrowed.length === 1)
             return narrowed[0];
     }
@@ -286,7 +336,9 @@ function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLoc
     }
     // Same argument-type + conversion-rank narrowing for the model pool.
     if (defs.length > 1) {
-        const narrowed = narrowOverloadCandidates(defs, callArity, callArgTypes, conversionRankFn);
+        const narrowed = narrowOverloadCandidates(defs, callArity, callArgTypes, {
+            conversionRankFn,
+        });
         if (narrowed.length === 1)
             return narrowed[0];
     }
@@ -345,7 +397,7 @@ function pickConstructorOrClass(classDef, workspaceIndex) {
  *  Exported for unit testing — language-agnostic logic, exercised
  *  via synthetic stubs in `pick-implicit-this-overload.test.ts`. The
  *  production call site is `applyFreeCallFallback` immediately above. */
-export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, conversionRankFn) {
+export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, hookCtx) {
     // Find the enclosing Class scope by walking parents.
     let curId = site.inScope;
     let classScopeId;
@@ -374,7 +426,10 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, co
     // ambiguous narrowing (multiple compatible candidates with no
     // disambiguating signal) leaves the call unresolved rather than
     // routing to an arbitrary first overload by registration order.
-    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, conversionRankFn);
+    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        conversionRankFn: hookCtx?.conversionRankFn,
+        constraintCompatibility: hookCtx?.constraintCompatibility,
+    });
     if (candidates.length !== 1)
         return undefined;
     return candidates[0];

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -25,14 +25,19 @@
  *      counts as a match. Mismatches disqualify. A non-empty typed
  *      result wins; otherwise return the arity-filtered candidates.
  *   4b. When the exact-type filter from step 4 returns empty AND a
- *       `conversionRankFn` is provided, rank candidates via pairwise
- *       dominance comparison (ISO C++ [over.ics.rank]): F1 beats F2
- *       only when F1 is not worse for every arg and better for at
- *       least one. Non-dominated candidates are returned; multiple
- *       survivors are genuinely ambiguous.
+ *       `conversionRankFn` is provided (via `hookCtx`), rank candidates
+ *       via pairwise dominance comparison (ISO C++ [over.ics.rank]):
+ *       F1 beats F2 only when F1 is not worse for every arg and better
+ *       for at least one. Non-dominated candidates are returned;
+ *       multiple survivors are genuinely ambiguous.
+ *   4c. Final per-candidate constraint filter (SFINAE / `requires`).
+ *       When `constraintCompatibility` is provided via `hookCtx`, drop
+ *       candidates whose template constraints provably fail at the
+ *       call site. Three-valued; `'unknown'` keeps the candidate
+ *       (monotonicity).
  *   5. Empty input returns empty output.
  */
-import type { SymbolDefinition } from '../../../../_shared/index.js';
+import type { ArityVerdict, Callsite, ConstraintContext, SymbolDefinition } from '../../../../_shared/index.js';
 /**
  * Per-slot conversion-rank function. Returns a numeric cost for
  * converting `argType` to `paramType`:
@@ -45,7 +50,25 @@ import type { SymbolDefinition } from '../../../../_shared/index.js';
  * on normalized type strings (output of the language's type normalizer).
  */
 export type ConversionRankFn = (argType: string, paramType: string) => number;
-export declare function narrowOverloadCandidates(overloads: readonly SymbolDefinition[], argCount: number | undefined, argTypes: readonly string[] | undefined, conversionRankFn?: ConversionRankFn): readonly SymbolDefinition[];
+/**
+ * Optional hook bundle for narrowing extension points. Threaded in
+ * from `pickOverload` / `pickImplicitThisOverload` so per-language
+ * narrowing can layer in conversion-rank scoring (#1606) and
+ * constraint filtering (#1579) without changing the call signature
+ * at every site. Each hook is independently optional — leaving both
+ * undefined preserves the legacy arity + exact-type behavior.
+ */
+export interface OverloadNarrowingHookCtx {
+    /** Conversion-rank scoring fallback (step 4b). Engages when the
+     *  exact-type filter rejects every candidate. */
+    readonly conversionRankFn?: ConversionRankFn;
+    /** Constraint filter (step 4c). Drops candidates whose template
+     *  guards (SFINAE `enable_if_t`, C++20 `requires`, future Rust
+     *  trait bounds, etc.) provably fail at the call site. Three-valued
+     *  — `'unknown'` keeps the candidate (monotonicity). */
+    readonly constraintCompatibility?: (callsite: Callsite, def: SymbolDefinition, ctx: ConstraintContext) => ArityVerdict;
+}
+export declare function narrowOverloadCandidates(overloads: readonly SymbolDefinition[], argCount: number | undefined, argTypes: readonly string[] | undefined, hookCtx?: OverloadNarrowingHookCtx): readonly SymbolDefinition[];
 /**
  * Detect when >1 candidate share identical `parameterTypes` after the
  * per-language normalizer has collapsed distinct underlying types. This

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -25,14 +25,19 @@
  *      counts as a match. Mismatches disqualify. A non-empty typed
  *      result wins; otherwise return the arity-filtered candidates.
  *   4b. When the exact-type filter from step 4 returns empty AND a
- *       `conversionRankFn` is provided, rank candidates via pairwise
- *       dominance comparison (ISO C++ [over.ics.rank]): F1 beats F2
- *       only when F1 is not worse for every arg and better for at
- *       least one. Non-dominated candidates are returned; multiple
- *       survivors are genuinely ambiguous.
+ *       `conversionRankFn` is provided (via `hookCtx`), rank candidates
+ *       via pairwise dominance comparison (ISO C++ [over.ics.rank]):
+ *       F1 beats F2 only when F1 is not worse for every arg and better
+ *       for at least one. Non-dominated candidates are returned;
+ *       multiple survivors are genuinely ambiguous.
+ *   4c. Final per-candidate constraint filter (SFINAE / `requires`).
+ *       When `constraintCompatibility` is provided via `hookCtx`, drop
+ *       candidates whose template constraints provably fail at the
+ *       call site. Three-valued; `'unknown'` keeps the candidate
+ *       (monotonicity).
  *   5. Empty input returns empty output.
  */
-export function narrowOverloadCandidates(overloads, argCount, argTypes, conversionRankFn) {
+export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx) {
     if (overloads.length === 0)
         return [];
     const arityMatches = argCount === undefined
@@ -67,6 +72,7 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, conversi
     // args).
     const anyUnknownBounds = overloads.some((d) => d.parameterCount === undefined && d.requiredParameterCount === undefined);
     const candidates = arityMatches.length > 0 ? arityMatches : anyUnknownBounds ? overloads : [];
+    let result = candidates;
     if (argTypes !== undefined && argTypes.length > 0) {
         const typed = candidates.filter((d) => {
             const params = d.parameterTypes;
@@ -80,21 +86,46 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, conversi
             }
             return true;
         });
-        if (typed.length > 0)
-            return typed;
-        // ── Conversion-rank scoring (step 4b) ──────────────────────────
-        // The exact-type filter above rejected every candidate. When a
-        // per-language conversion-rank function is available, rank via
-        // pairwise dominance: F1 beats F2 only when F1 is not worse for
-        // every arg and better for at least one. Non-dominated candidates
-        // are returned; multiple survivors are genuinely ambiguous.
-        if (conversionRankFn !== undefined) {
-            const ranked = rankByConversion(candidates, argTypes, conversionRankFn);
+        if (typed.length > 0) {
+            result = typed;
+        }
+        else if (hookCtx?.conversionRankFn !== undefined) {
+            // ── Conversion-rank scoring (step 4b) ──────────────────────────
+            // The exact-type filter rejected every candidate. Rank via
+            // pairwise dominance: F1 beats F2 only when F1 is not worse for
+            // every arg and better for at least one. Non-dominated candidates
+            // are returned; multiple survivors are genuinely ambiguous. When
+            // ranking also yields empty, fall through to the arity-filtered
+            // `candidates` set — matches pre-#1606 behavior.
+            const ranked = rankByConversion(candidates, argTypes, hookCtx.conversionRankFn);
             if (ranked.length > 0)
-                return ranked;
+                result = ranked;
         }
     }
-    return candidates;
+    // Constraint filter (step 4c; Tier-A — SFINAE / `requires` clauses).
+    // Runs after arity, exact-type, and conversion-rank filters so the
+    // hook only sees candidates already viable on the other axes.
+    // Three-valued: `'compatible'` and `'unknown'` keep the candidate
+    // (monotonicity — adding a predicate must never cause a wrong edge);
+    // only `'incompatible'` drops it. Candidates without
+    // `templateConstraints` are always kept.
+    //
+    // No fallback to the unconstrained set when this filter empties the
+    // candidate list: a fully-`'incompatible'` verdict is authoritative.
+    // The downstream `OVERLOAD_AMBIGUOUS` sentinel still guards the empty
+    // case, so a buggy hook that wrongly returns `'incompatible'` for
+    // every candidate degrades to today's "suppress edge" behavior rather
+    // than emitting a wrong edge.
+    if (hookCtx?.constraintCompatibility !== undefined && argCount !== undefined) {
+        const callsite = { arity: argCount };
+        const ctx = argTypes !== undefined ? { argumentTypes: argTypes } : {};
+        result = result.filter((def) => {
+            if (def.templateConstraints === undefined)
+                return true;
+            return hookCtx.constraintCompatibility(callsite, def, ctx) !== 'incompatible';
+        });
+    }
+    return result;
 }
 /**
  * Pairwise dominance comparison (ISO C++ [over.ics.rank]).

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -41,7 +41,7 @@ import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel): number;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -249,7 +249,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     for (const ownerId of chain) {
                         const methodOverloads = model.methods.lookupAllByOwner(ownerId, memberName);
                         if (methodOverloads.length > 0) {
-                            const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes, provider.conversionRankFn);
+                            const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes, {
+                                conversionRankFn: provider.conversionRankFn,
+                                constraintCompatibility: provider.constraintCompatibility,
+                            });
                             if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
                                 ambiguous = true;
                                 break;
@@ -467,7 +470,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     let memberDef;
                     let ambiguous = false;
                     for (const ownerId of chain) {
-                        const picked = pickOverload(ownerId, memberName, site, model, provider.conversionRankFn);
+                        const picked = pickOverload(ownerId, memberName, site, model, provider);
                         if (picked === OVERLOAD_AMBIGUOUS) {
                             ambiguous = true;
                             break;
@@ -518,7 +521,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
  *  types when multiple overloads share the name. Falls back to the
  *  first-seen def (legacy `findOwnedMember` semantics) when there's
  *  no narrowing signal or when `argumentTypes` is unavailable. */
-function pickOverload(ownerId, memberName, site, model, conversionRankFn) {
+function pickOverload(ownerId, memberName, site, model, provider) {
     const overloads = model.methods.lookupAllByOwner(ownerId, memberName);
     if (overloads.length === 0) {
         // Non-callable member (field / property / variable) — ACCESSES
@@ -528,7 +531,10 @@ function pickOverload(ownerId, memberName, site, model, conversionRankFn) {
     }
     if (overloads.length === 1)
         return overloads[0];
-    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, conversionRankFn);
+    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        conversionRankFn: provider.conversionRankFn,
+        constraintCompatibility: provider.constraintCompatibility,
+    });
     // When narrowing leaves >1 candidate that share identical normalized
     // parameter-types (e.g., C++ `f(int)` vs `f(long)` both collapsed to
     // `['int']` by `normalizeCppParamType`), suppress the edge entirely.

package/dist/core/ingestion/scope-resolution/pipeline/reconcile-ownership.d.ts

@@ -18,8 +18,8 @@
  * undefined `ownerId` is reachable via either:
  *   - `model.methods.lookupAllByOwner(ownerId, simpleName)` — if the
  *     def is a Method / Function / Constructor, OR
- *   - `model.fields.lookupFieldByOwner(ownerId, simpleName)` — if the
- *     def is a Property / Variable.
+ *   - `model.fields.lookupAllByOwner(ownerId, simpleName)` — if the
+ *     def is a Property / Variable / Const / Static.
  *
  * This invariant is the foundation of Contract Invariant I9
  * (`contract/scope-resolver.ts`): scope-resolution passes MUST read
@@ -47,6 +47,8 @@ export interface ReconcileStats {
     readonly methodsRegistered: number;
     /** Property/Variable defs registered into FieldRegistry. */
     readonly fieldsRegistered: number;
+    /** Class-like nested type defs registered into TypeRegistry by owner. */
+    readonly nestedTypesRegistered: number;
     /** Defs already present (idempotent skip). */
     readonly skippedAlreadyPresent: number;
 }

package/dist/core/ingestion/scope-resolution/pipeline/reconcile-ownership.js

@@ -18,8 +18,8 @@
  * undefined `ownerId` is reachable via either:
  *   - `model.methods.lookupAllByOwner(ownerId, simpleName)` — if the
  *     def is a Method / Function / Constructor, OR
- *   - `model.fields.lookupFieldByOwner(ownerId, simpleName)` — if the
- *     def is a Property / Variable.
+ *   - `model.fields.lookupAllByOwner(ownerId, simpleName)` — if the
+ *     def is a Property / Variable / Const / Static.
  *
  * This invariant is the foundation of Contract Invariant I9
  * (`contract/scope-resolver.ts`): scope-resolution passes MUST read
@@ -41,9 +41,25 @@
  * follow-up plan.
  */
 import { simpleQualifiedName } from '../graph-bridge/ids.js';
+const NESTED_TYPE_KINDS = new Set([
+    'Class',
+    'Interface',
+    'Enum',
+    'Struct',
+    'Union',
+    'Trait',
+    'TypeAlias',
+    'Typedef',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Template',
+    'Namespace',
+]);
 export function reconcileOwnership(parsedFiles, model) {
     let methodsRegistered = 0;
     let fieldsRegistered = 0;
+    let nestedTypesRegistered = 0;
     let skippedAlreadyPresent = 0;
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
@@ -62,18 +78,30 @@ export function reconcileOwnership(parsedFiles, model) {
                 model.methods.register(ownerId, simple, def);
                 methodsRegistered++;
             }
-            else if (def.type === 'Property' || def.type === 'Variable') {
-                const existing = model.fields.lookupFieldByOwner(ownerId, simple);
-                if (existing !== undefined && existing.nodeId === def.nodeId) {
+            else if (def.type === 'Property' ||
+                def.type === 'Variable' ||
+                def.type === 'Const' ||
+                def.type === 'Static') {
+                const existing = model.fields.lookupAllByOwner(ownerId, simple);
+                if (existing.some((e) => e.nodeId === def.nodeId)) {
                     skippedAlreadyPresent++;
                     continue;
                 }
                 model.fields.register(ownerId, simple, def);
                 fieldsRegistered++;
             }
+            else if (NESTED_TYPE_KINDS.has(def.type)) {
+                const existing = model.types.lookupAllByOwner(ownerId, simple);
+                if (existing.some((e) => e.nodeId === def.nodeId)) {
+                    skippedAlreadyPresent++;
+                    continue;
+                }
+                model.types.registerByOwner(ownerId, simple, def);
+                nestedTypesRegistered++;
+            }
         }
     }
-    return { methodsRegistered, fieldsRegistered, skippedAlreadyPresent };
+    return { methodsRegistered, fieldsRegistered, nestedTypesRegistered, skippedAlreadyPresent };
 }
 /**
  * Debug-mode parity validator. Runs only when
@@ -111,14 +139,25 @@ export function validateOwnershipParity(parsedFiles, model, onWarn) {
                     mismatches++;
                 }
             }
-            else if (def.type === 'Property' || def.type === 'Variable') {
-                const found = model.fields.lookupFieldByOwner(ownerId, simple);
-                if (found === undefined || found.nodeId !== def.nodeId) {
+            else if (def.type === 'Property' ||
+                def.type === 'Variable' ||
+                def.type === 'Const' ||
+                def.type === 'Static') {
+                const found = model.fields.lookupAllByOwner(ownerId, simple);
+                if (!found.some((d) => d.nodeId === def.nodeId)) {
                     onWarn(`semantic-model parity: ${def.type} ${def.nodeId} (${parsed.filePath}) ` +
                         `owned by ${ownerId} as "${simple}" not in FieldRegistry`);
                     mismatches++;
                 }
             }
+            else if (NESTED_TYPE_KINDS.has(def.type)) {
+                const found = model.types.lookupAllByOwner(ownerId, simple);
+                if (!found.some((d) => d.nodeId === def.nodeId)) {
+                    onWarn(`semantic-model parity: ${def.type} ${def.nodeId} (${parsed.filePath}) ` +
+                        `owned by ${ownerId} as "${simple}" not in TypeRegistry owner index`);
+                    mismatches++;
+                }
+            }
         }
     }
     return mismatches;

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -22,6 +22,7 @@
  *
  * Plan: `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
+import { lookupOwnedMembersByOwner } from '../../model/owned-members-lookup.js';
 import { reconcileOwnership, validateOwnershipParity } from './reconcile-ownership.js';
 import { validateBindingsImmutability } from './validate-bindings-immutability.js';
 import { extractParsedFile } from '../../scope-extractor-bridge.js';
@@ -236,6 +237,7 @@ export function runScopeResolution(input, provider) {
     const { referenceIndex, stats: resolveStats } = resolveReferenceSites({
         scopes: indexes,
         providers: registryProviders,
+        ownedMembersByOwner: (ownerDefId, memberName) => lookupOwnedMembersByOwner(readonlyModel, ownerDefId, memberName),
     });
     const tResolve = PROF ? process.hrtime.bigint() : 0n;
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
@@ -250,6 +252,7 @@ export function runScopeResolution(input, provider) {
         isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
         resolveAdlCandidates: provider.resolveAdlCandidates,
         conversionRankFn: provider.conversionRankFn,
+        constraintCompatibility: provider.constraintCompatibility,
     });
     const { emitted, skipped } = emitReferencesViaLookup(graph, indexes, referenceIndex, nodeLookup, handledSites);
     const importsEmitted = emitImportEdges(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);

package/dist/core/ingestion/utils/template-arguments.d.ts

@@ -9,3 +9,22 @@
 export declare function extractTemplateArguments(text: string): string[] | undefined;
 export declare function stripTemplateArguments(text: string): string;
 export declare function templateArgumentsIdTag(templateArguments?: readonly string[]): string;
+/**
+ * Stable short hash for the opaque `SymbolDefinition.templateConstraints`
+ * payload (issue #1579). Two function-template overloads with identical
+ * `parameterTypes` but mutually-exclusive SFINAE constraints
+ * (`enable_if_t<is_integral_v<T>>` vs `enable_if_t<is_floating_point_v<T>>`)
+ * must produce distinct graph node IDs so the constraint-filter step
+ * has two candidates to narrow between. Without this they collapse to
+ * a single Function node and the SFINAE golden case can only emit one
+ * edge regardless of resolver fixes.
+ *
+ * FNV-1a 32-bit, base36 encoded. Deterministic; non-cryptographic — the
+ * tag's job is collision-avoidance among same-name overloads in one
+ * file, not security.
+ */
+export declare function constraintsHash(jsonText: string): string;
+/** Build the `~c:<hash>` ID suffix from an opaque constraint payload.
+ *  Returns empty string when the payload is absent so callers can
+ *  string-concatenate unconditionally. */
+export declare function templateConstraintsIdTag(payload: unknown): string;

package/dist/core/ingestion/utils/template-arguments.js

@@ -63,3 +63,33 @@ export function templateArgumentsIdTag(templateArguments) {
         return '';
     return `~${templateArguments.join(',')}`;
 }
+/**
+ * Stable short hash for the opaque `SymbolDefinition.templateConstraints`
+ * payload (issue #1579). Two function-template overloads with identical
+ * `parameterTypes` but mutually-exclusive SFINAE constraints
+ * (`enable_if_t<is_integral_v<T>>` vs `enable_if_t<is_floating_point_v<T>>`)
+ * must produce distinct graph node IDs so the constraint-filter step
+ * has two candidates to narrow between. Without this they collapse to
+ * a single Function node and the SFINAE golden case can only emit one
+ * edge regardless of resolver fixes.
+ *
+ * FNV-1a 32-bit, base36 encoded. Deterministic; non-cryptographic — the
+ * tag's job is collision-avoidance among same-name overloads in one
+ * file, not security.
+ */
+export function constraintsHash(jsonText) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < jsonText.length; i++) {
+        h ^= jsonText.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(36);
+}
+/** Build the `~c:<hash>` ID suffix from an opaque constraint payload.
+ *  Returns empty string when the payload is absent so callers can
+ *  string-concatenate unconditionally. */
+export function templateConstraintsIdTag(payload) {
+    if (payload === undefined || payload === null)
+        return '';
+    return `~c:${constraintsHash(JSON.stringify(payload))}`;
+}

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -3,7 +3,7 @@ import type { ExtractedHeritage } from '../model/heritage-map.js';
 import { type MixedChainStep } from '../utils/call-analysis.js';
 import type { ConstructorBinding } from '../type-env.js';
 import type { NamedBinding } from '../named-bindings/types.js';
-import type { NodeLabel } from '../../../_shared/index.js';
+import type { NodeLabel, ParameterTypeClass } from '../../../_shared/index.js';
 import type { ParsedFile } from '../../../_shared/index.js';
 interface ParsedNode {
     id: string;
@@ -38,6 +38,7 @@ interface ParsedSymbol {
     parameterCount?: number;
     requiredParameterCount?: number;
     parameterTypes?: string[];
+    parameterTypeClasses?: ParameterTypeClass[];
     returnType?: string;
     declaredType?: string;
     templateArguments?: string[];

package/dist/core/ingestion/workers/parse-worker.js

@@ -1801,6 +1801,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 parameterCount: methodProps.parameterCount,
                 requiredParameterCount: methodProps.requiredParameterCount,
                 parameterTypes: methodProps.parameterTypes,
+                parameterTypeClasses: methodProps.parameterTypeClasses,
                 returnType: methodProps.returnType,
                 ...(declaredType !== undefined ? { declaredType } : {}),
                 ...(classTemplateArguments !== undefined && classTemplateArguments.length > 0