gitnexus 1.6.5 → 1.6.6-rc.10

package/dist/core/ingestion/model/owned-members-lookup.js

@@ -0,0 +1,43 @@
+/**
+ * Owner-keyed member lookup for Step 2 (RFC #909 / PR #1656).
+ *
+ * Merges MethodRegistry + FieldRegistry hits for `(ownerDefId, memberName)`
+ * in O(1) map time per registry — no `defs.byId` scan. Callers that omit
+ * this helper and leave `ownedMembersByOwner` unset fall back to an O(|defs|)
+ * compatibility scan inside `lookupCore.collectOwnedMembers`.
+ */
+const EMPTY = Object.freeze([]);
+/**
+ * Production hook for `RegistryContext.ownedMembersByOwner`.
+ * Returns `[]` on miss (authoritative indexed empty) — never `undefined`.
+ *
+ * Merges hits from all three owner-keyed registries (methods, fields,
+ * nested types) under the same `(ownerDefId, memberName)` key. The
+ * caller's `acceptedKinds` filter in `lookupCore` picks the right subset.
+ */
+export function lookupOwnedMembersByOwner(model, ownerDefId, memberName) {
+    const methods = model.methods.lookupAllByOwner(ownerDefId, memberName);
+    const fields = model.fields.lookupAllByOwner(ownerDefId, memberName);
+    const nestedTypes = model.types.lookupAllByOwner(ownerDefId, memberName);
+    const methodCount = methods.length;
+    const fieldCount = fields.length;
+    const typeCount = nestedTypes.length;
+    const total = methodCount + fieldCount + typeCount;
+    if (total === 0)
+        return EMPTY;
+    if (methodCount === total)
+        return methods;
+    if (fieldCount === total)
+        return fields;
+    if (typeCount === total)
+        return nestedTypes;
+    const merged = new Array(total);
+    let i = 0;
+    for (let j = 0; j < methodCount; j++)
+        merged[i++] = methods[j];
+    for (let j = 0; j < fieldCount; j++)
+        merged[i++] = fields[j];
+    for (let j = 0; j < typeCount; j++)
+        merged[i++] = nestedTypes[j];
+    return merged;
+}

package/dist/core/ingestion/model/symbol-table.d.ts

@@ -33,7 +33,7 @@
  * import from `./model/` here, you are going the wrong way — move the
  * logic up the dependency chain instead.
  */
-import type { NodeLabel, SymbolDefinition } from '../../../_shared/index.js';
+import type { NodeLabel, ParameterTypeClass, SymbolDefinition } from '../../../_shared/index.js';
 /**
  * Class-like NodeLabels — used for qualifiedName fallback inside
  * `SymbolTable.add()` and (via import into `model/registration-table.ts`)
@@ -97,6 +97,7 @@ export interface AddMetadata {
     parameterCount?: number;
     requiredParameterCount?: number;
     parameterTypes?: string[];
+    parameterTypeClasses?: ParameterTypeClass[];
     returnType?: string;
     declaredType?: string;
     templateArguments?: string[];

package/dist/core/ingestion/model/symbol-table.js

@@ -128,6 +128,9 @@ export const createSymbolTable = () => {
             ...(metadata?.parameterTypes !== undefined
                 ? { parameterTypes: metadata.parameterTypes }
                 : {}),
+            ...(metadata?.parameterTypeClasses !== undefined
+                ? { parameterTypeClasses: metadata.parameterTypeClasses }
+                : {}),
             ...(metadata?.returnType !== undefined ? { returnType: metadata.returnType } : {}),
             ...(metadata?.declaredType !== undefined ? { declaredType: metadata.declaredType } : {}),
             ...(metadata?.templateArguments !== undefined

package/dist/core/ingestion/model/type-registry.d.ts

@@ -27,12 +27,21 @@ export interface TypeRegistry {
      * Returned array is a view into the live index — do not mutate.
      */
     lookupImplByName(name: string): readonly SymbolDefinition[];
+    /**
+     * Look up nested-type defs registered under `(ownerNodeId, simpleName)`
+     * in registration order. Returns `[]` on miss. Used by Step 2 Receiver/MRO
+     * resolution when the receiver's owner declares nested classes/structs/
+     * enums/typedefs/etc. that the caller's `acceptedKinds` includes.
+     */
+    lookupAllByOwner(ownerNodeId: string, simpleName: string): readonly SymbolDefinition[];
 }
 export interface MutableTypeRegistry extends TypeRegistry {
     /** Register a class-like type by name and qualified name. */
     registerClass(name: string, qualifiedName: string, def: SymbolDefinition): void;
     /** Register a Rust Impl block by name. */
     registerImpl(name: string, def: SymbolDefinition): void;
+    /** Register a nested type under its owner. Appends when the key already exists. */
+    registerByOwner(ownerNodeId: string, simpleName: string, def: SymbolDefinition): void;
     /** Clear all entries. */
     clear(): void;
 }

package/dist/core/ingestion/model/type-registry.js

@@ -5,6 +5,7 @@
  * Eagerly-populated indexes keyed by symbol name and qualified name.
  * Also includes a separate index for Rust Impl blocks.
  */
+const EMPTY = Object.freeze([]);
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
@@ -12,6 +13,7 @@ export const createTypeRegistry = () => {
     const classByName = new Map();
     const classByQualifiedName = new Map();
     const implByName = new Map();
+    const nestedByOwner = new Map();
     const lookupClassByName = (name) => {
         return classByName.get(name) ?? [];
     };
@@ -21,6 +23,9 @@ export const createTypeRegistry = () => {
     const lookupImplByName = (name) => {
         return implByName.get(name) ?? [];
     };
+    const lookupAllByOwner = (ownerNodeId, simpleName) => {
+        return nestedByOwner.get(`${ownerNodeId}\0${simpleName}`) ?? EMPTY;
+    };
     const registerClass = (name, qualifiedName, def) => {
         const existing = classByName.get(name);
         if (existing) {
@@ -46,17 +51,30 @@ export const createTypeRegistry = () => {
             implByName.set(name, [def]);
         }
     };
+    const registerByOwner = (ownerNodeId, simpleName, def) => {
+        const key = `${ownerNodeId}\0${simpleName}`;
+        const existing = nestedByOwner.get(key);
+        if (existing) {
+            existing.push(def);
+        }
+        else {
+            nestedByOwner.set(key, [def]);
+        }
+    };
     const clear = () => {
         classByName.clear();
         classByQualifiedName.clear();
         implByName.clear();
+        nestedByOwner.clear();
     };
     return {
         lookupClassByName,
         lookupClassByQualifiedName,
         lookupImplByName,
+        lookupAllByOwner,
         registerClass,
         registerImpl,
+        registerByOwner,
         clear,
     };
 };

package/dist/core/ingestion/parsing-processor.js

@@ -11,7 +11,7 @@ import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCapt
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from './utils/method-props.js';
-import { extractTemplateArguments, templateArgumentsIdTag } from './utils/template-arguments.js';
+import { extractTemplateArguments, templateArgumentsIdTag, templateConstraintsIdTag, } from './utils/template-arguments.js';
 import { logger } from '../logger.js';
 import { getTreeSitterBufferSize, getTreeSitterContentByteLength, TREE_SITTER_MAX_BUFFER, } from './constants.js';
 // ============================================================================
@@ -57,6 +57,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults) => {
                 parameterCount: sym.parameterCount,
                 requiredParameterCount: sym.requiredParameterCount,
                 parameterTypes: sym.parameterTypes,
+                parameterTypeClasses: sym.parameterTypeClasses,
                 returnType: sym.returnType,
                 declaredType: sym.declaredType,
                 templateArguments: sym.templateArguments,
@@ -499,7 +500,35 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 classTemplateArguments.length > 0
                 ? templateArgumentsIdTag(classTemplateArguments)
                 : '';
-            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}`);
+            // SFINAE / `requires`-clause aware ID disambiguation (issue #1579).
+            // Function-template overloads with identical parameterTypes but
+            // mutually-exclusive constraints (e.g. `enable_if_t<is_integral_v<T>>`
+            // vs `enable_if_t<is_floating_point_v<T>>`) need distinct graph
+            // nodes so the constraint-filter step in `narrowOverloadCandidates`
+            // has two candidates to narrow between. Without this tag they
+            // collapse to a single Function node and the SFINAE call resolves
+            // to only one edge regardless of which overload's constraint holds.
+            // The provider hook is the right invocation point — parsing-processor
+            // sees raw tree-sitter matches without the `@`-prefixed synthetic
+            // captures `scope-extractor` consumes, so we delegate extraction to
+            // the language adapter (C++ implements this; other languages opt out).
+            let parsedTemplateConstraints = undefined;
+            let constraintsTag = '';
+            if ((nodeLabel === 'Function' || nodeLabel === 'Method') &&
+                provider.extractTemplateConstraints !== undefined &&
+                definitionNode !== null) {
+                try {
+                    parsedTemplateConstraints = provider.extractTemplateConstraints(definitionNode);
+                    if (parsedTemplateConstraints !== undefined) {
+                        constraintsTag = templateConstraintsIdTag(parsedTemplateConstraints);
+                    }
+                }
+                catch {
+                    parsedTemplateConstraints = undefined;
+                    constraintsTag = '';
+                }
+            }
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${constraintsTag}`);
             const classNodeForSymbol = definitionNodeForRange || definitionNode || nameNode;
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
@@ -528,6 +557,9 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                     ...(classTemplateArguments !== undefined && classTemplateArguments.length > 0
                         ? { templateArguments: classTemplateArguments }
                         : {}),
+                    ...(parsedTemplateConstraints !== undefined
+                        ? { templateConstraints: parsedTemplateConstraints }
+                        : {}),
                     ...(frameworkHint
                         ? {
                             astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
@@ -579,6 +611,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 parameterCount: methodProps.parameterCount,
                 requiredParameterCount: methodProps.requiredParameterCount,
                 parameterTypes: methodProps.parameterTypes,
+                parameterTypeClasses: methodProps.parameterTypeClasses,
                 returnType: methodProps.returnType,
                 declaredType,
                 templateArguments: classTemplateArguments,

package/dist/core/ingestion/resolve-references.d.ts

@@ -37,12 +37,14 @@
  *     resolution but not emitted as multiple edges; callers that want
  *     branch-on-ambiguity behavior should consume the registries directly.
  */
-import { CLASS_KINDS, FIELD_KINDS, METHOD_KINDS, type ReferenceIndex, type RegistryProviders } from '../../_shared/index.js';
+import { CLASS_KINDS, FIELD_KINDS, METHOD_KINDS, type ReferenceIndex, type RegistryContext, type RegistryProviders } from '../../_shared/index.js';
 import type { ScopeResolutionIndexes } from './model/scope-resolution-indexes.js';
 export interface ResolveReferencesInput {
     readonly scopes: ScopeResolutionIndexes;
     /** Provider hooks consumed by the registries (e.g. `arityCompatibility`). */
     readonly providers?: RegistryProviders;
+    /** Required owner-keyed member lookup used by Step 2 receiver/MRO walks. */
+    readonly ownedMembersByOwner: RegistryContext['ownedMembersByOwner'];
 }
 export interface ResolveStats {
     readonly sitesProcessed: number;

package/dist/core/ingestion/resolve-references.js

@@ -51,6 +51,7 @@ export function resolveReferenceSites(input) {
         defs: scopes.defs,
         qualifiedNames: scopes.qualifiedNames,
         moduleScopes: scopes.moduleScopes,
+        ownedMembersByOwner: input.ownedMembersByOwner,
         methodDispatch: scopes.methodDispatch,
         providers,
     };
@@ -135,7 +136,10 @@ function lookupForSite(site, classRegistry, methodRegistry, fieldRegistry) {
         case 'write': {
             // Try field first; fall through to method then class so bare-name
             // reads of a function (e.g. `cb = save`) still resolve.
-            const fieldHits = fieldRegistry.lookup(site.name, site.inScope);
+            const fieldOpts = {
+                ...(site.explicitReceiver !== undefined ? { explicitReceiver: site.explicitReceiver } : {}),
+            };
+            const fieldHits = fieldRegistry.lookup(site.name, site.inScope, fieldOpts);
             if (fieldHits.length > 0)
                 return fieldHits;
             const methodHits = methodRegistry.lookup(site.name, site.inScope);

package/dist/core/ingestion/scope-extractor.js

@@ -372,8 +372,10 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
     const parameterCount = parseIntCapture(match['@declaration.parameter-count']);
     const requiredParameterCount = parseIntCapture(match['@declaration.required-parameter-count']);
     const parameterTypes = parseJsonStringArrayCapture(match['@declaration.parameter-types']);
+    const parameterTypeClasses = parseJsonParameterTypeClassesCapture(match['@declaration.parameter-type-classes']);
     const declaredType = match['@declaration.field-type']?.text;
     const returnType = match['@declaration.return-type']?.text;
+    const templateConstraints = parseJsonCapture(match['@declaration.template-constraints']);
     return {
         nodeId: makeDefId(filePath, anchor.range, type, nameCap.text),
         filePath,
@@ -382,17 +384,77 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
         ...(parameterCount !== undefined ? { parameterCount } : {}),
         ...(requiredParameterCount !== undefined ? { requiredParameterCount } : {}),
         ...(parameterTypes !== undefined ? { parameterTypes } : {}),
+        ...(parameterTypeClasses !== undefined ? { parameterTypeClasses } : {}),
         ...(declaredType !== undefined ? { declaredType } : {}),
         ...(returnType !== undefined ? { returnType } : {}),
         ...(templateArguments !== undefined ? { templateArguments } : {}),
+        ...(templateConstraints !== undefined ? { templateConstraints } : {}),
     };
 }
+/** Parse an opaque JSON payload synthesized by per-language captures
+ *  (e.g. C++ `@declaration.template-constraints`). Producer owns the
+ *  shape; shared code threads it through as `unknown` per the
+ *  `SymbolDefinition.templateConstraints` contract. */
+function parseJsonCapture(cap) {
+    if (cap === undefined)
+        return undefined;
+    try {
+        return JSON.parse(cap.text);
+    }
+    catch {
+        return undefined;
+    }
+}
 function parseIntCapture(cap) {
     if (cap === undefined)
         return undefined;
     const n = Number.parseInt(cap.text, 10);
     return Number.isFinite(n) ? n : undefined;
 }
+function parseJsonParameterTypeClassesCapture(cap) {
+    if (cap === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(cap.text);
+        if (!Array.isArray(parsed))
+            return undefined;
+        const out = [];
+        for (const item of parsed) {
+            if (item === null || typeof item !== 'object')
+                return undefined;
+            const o = item;
+            if (typeof o.base !== 'string')
+                return undefined;
+            if (o.cv !== 'none' &&
+                o.cv !== 'const' &&
+                o.cv !== 'volatile' &&
+                o.cv !== 'const volatile' &&
+                o.cv !== 'unknown') {
+                return undefined;
+            }
+            if (o.indirection !== 'value' &&
+                o.indirection !== 'lvalue-ref' &&
+                o.indirection !== 'rvalue-ref' &&
+                o.indirection !== 'pointer' &&
+                o.indirection !== 'unknown') {
+                return undefined;
+            }
+            if (typeof o.pointerDepth !== 'number' || !Number.isFinite(o.pointerDepth)) {
+                return undefined;
+            }
+            out.push({
+                base: o.base,
+                cv: o.cv,
+                indirection: o.indirection,
+                pointerDepth: o.pointerDepth,
+            });
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
 function parseJsonStringArrayCapture(cap) {
     if (cap === undefined)
         return undefined;
@@ -747,6 +809,7 @@ const KNOWN_SUB_TAGS = new Set([
     '@declaration.parameter-count',
     '@declaration.required-parameter-count',
     '@declaration.parameter-types',
+    '@declaration.template-constraints',
 ]);
 /**
  * Return the anchor capture for a match — the one whose name begins with

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -250,7 +250,7 @@
  * Plan that introduced most of these invariants:
  * `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
-import type { BindingRef, Callsite, ParsedFile, ScopeId, SupportedLanguages, SymbolDefinition } from '../../../../_shared/index.js';
+import type { BindingRef, Callsite, ConstraintContext, ParsedFile, ScopeId, SupportedLanguages, SymbolDefinition } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { LanguageProvider } from '../../language-provider.js';
@@ -264,6 +264,9 @@ import type { ConversionRankFn } from '../passes/overload-narrowing.js';
 export type LinearizeStrategy = (classDefId: string, directParents: readonly string[], parentsByDefId: ReadonlyMap<string, readonly string[]>) => string[];
 /** Result of `ScopeResolver.arityCompatibility` — mirrors `RegistryProviders.arityCompatibility`. */
 export type ArityVerdict = 'compatible' | 'unknown' | 'incompatible';
+/** Re-exported for ScopeResolver consumers — same shape as
+ *  `RegistryProviders.constraintCompatibility`'s third parameter. */
+export type { ConstraintContext } from '../../../../_shared/index.js';
 export interface ScopeResolver {
     /** Identity for telemetry + per-language flag check. */
     readonly language: SupportedLanguages;
@@ -337,6 +340,23 @@ export interface ScopeResolver {
      * `(def, callsite)` and need an adapter at the wiring site.
      */
     arityCompatibility(callsite: Callsite, def: SymbolDefinition): ArityVerdict;
+    /**
+     * Per-language constraint compatibility between a callsite and a
+     * candidate `def` that carries `templateConstraints` metadata.
+     * Mirrors `arityCompatibility` semantics: the three-valued verdict
+     * MUST treat `'unknown'` as keep-candidate (monotonicity — adding
+     * a predicate can only narrow correctly, never produce a wrong
+     * edge). Consulted by `narrowOverloadCandidates` after the arity
+     * and parameter-type filters.
+     *
+     * Optional. Languages without constrained-overload semantics
+     * (SFINAE, `requires` clauses, trait bounds, conditional types)
+     * leave this undefined and the constraint filter is a pass-through.
+     *
+     * C++ is the first consumer; see `languages/cpp/constraint-filter.ts`
+     * for the Tier-A predicate registry and Kleene 3-valued evaluator.
+     */
+    readonly constraintCompatibility?: (callsite: Callsite, def: SymbolDefinition, ctx: ConstraintContext) => ArityVerdict;
     /**
      * Compute the method-dispatch order for every Class def in the
      * workspace. Python uses depth-first first-seen via

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.d.ts

@@ -41,6 +41,7 @@ export declare function resolveDefGraphId(filePath: string, def: {
     type?: NodeLabel;
     parameterTypes?: readonly string[];
     templateArguments?: readonly string[];
+    templateConstraints?: unknown;
 }, nodeLookup: GraphNodeLookup): string | undefined;
 /** Derive the simple (unqualified) name of a def from its `qualifiedName`. */
 export declare function simpleQualifiedName(def: SymbolDefinition): string | undefined;

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.js

@@ -18,6 +18,7 @@
  */
 import { generateId } from '../../../../lib/utils.js';
 import { qualifiedKey, simpleKey } from '../graph-bridge/node-lookup.js';
+import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
 /**
  * Labels that may legitimately ANCHOR a CALLS/ACCESSES edge as the
  * source ("caller"). A Variable / Property can be the TARGET of an
@@ -68,6 +69,19 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
     if (qn === undefined || qn.length === 0)
         return undefined;
     if (def.type !== undefined) {
+        // SFINAE / `requires`-clause disambiguation (issue #1579) — try the
+        // constraint-fingerprinted key FIRST. Two function-template overloads
+        // with identical `parameterTypes` but mutually-exclusive SFINAE
+        // constraints route to their distinct graph nodes via this key.
+        // Must run before the parameter-types key because both overloads
+        // share the latter.
+        if ((def.type === 'Function' || def.type === 'Method') &&
+            def.templateConstraints !== undefined) {
+            const cKey = qualifiedKey(filePath, def.type, `${qn}${templateConstraintsIdTag(def.templateConstraints)}`);
+            const cHit = nodeLookup.get(cKey);
+            if (cHit !== undefined)
+                return cHit;
+        }
         // Overload disambiguation: when the def carries parameter types,
         // try the parameter-typed key first so same-name same-arity
         // overloads route to their distinct graph nodes.

package/dist/core/ingestion/scope-resolution/graph-bridge/node-lookup.js

@@ -17,6 +17,7 @@
  * `SymbolDefinition.nodeId` values into the legacy graph-node ID
  * format that downstream consumers (queries, edges, MCP) expect.
  */
+import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
 /**
  * Parse a qualified name out of a Function/Method node id.
  *
@@ -86,6 +87,17 @@ export function buildGraphNodeLookup(graph) {
                 // Each overload is unique — set unconditionally.
                 lookup.set(pKey, node.id);
             }
+            // SFINAE / `requires`-clause disambiguation (issue #1579) — register
+            // a constraint-fingerprinted key so resolveDefGraphId can locate the
+            // correct overload by hashing the def's `templateConstraints`. Mirrors
+            // the parameter-types key but keys on the opaque constraint payload
+            // instead, separating two `process<T>` overloads whose
+            // `parameterTypes=['T']` would otherwise collide.
+            const tConstraints = props.templateConstraints;
+            if (tConstraints !== undefined && (node.label === 'Function' || node.label === 'Method')) {
+                const cKey = qualifiedKey(props.filePath, node.label, `${qualified}${templateConstraintsIdTag(tConstraints)}`);
+                lookup.set(cKey, node.id);
+            }
             if ((node.label === 'Class' ||
                 node.label === 'Struct' ||
                 node.label === 'Interface' ||

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

@@ -22,6 +22,7 @@ import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexe
 import type { SemanticModel } from '../../model/semantic-model.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
+import type { ScopeResolver } from '../contract/scope-resolver.js';
 import { type ConversionRankFn } from './overload-narrowing.js';
 export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, _referenceIndex: {
     readonly bySourceScope: ReadonlyMap<ScopeId, readonly Reference[]>;
@@ -44,6 +45,12 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
         };
     }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
     readonly conversionRankFn?: ConversionRankFn;
+    /** Optional per-language constraint hook threaded into
+     *  `narrowOverloadCandidates`. Drops candidates whose template
+     *  constraints (e.g. C++ `enable_if_t`, C++20 `requires`) provably
+     *  fail at the call site. Three-valued; `'unknown'` keeps the
+     *  candidate (monotonicity). */
+    readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
 }): number;
 /** Walk up from the call-site scope to the enclosing class scope,
  *  pick a method member by name with overload narrowing on arity +
@@ -63,4 +70,7 @@ export declare function pickImplicitThisOverload(site: {
     readonly name: string;
     readonly arity?: number;
     readonly argumentTypes?: readonly string[];
-}, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel, conversionRankFn?: ConversionRankFn): SymbolDefinition | undefined;
+}, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel, hookCtx?: {
+    readonly conversionRankFn?: ConversionRankFn;
+    readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
+}): SymbolDefinition | undefined;