gitnexus 1.6.4-rc.2 → 1.6.4-rc.21

package/dist/core/embeddings/embedding-pipeline.js

@@ -13,10 +13,21 @@ import { initEmbedder, embedBatch, embedText, embeddingToArray, isEmbedderReady,
 import { generateEmbeddingText } from './text-generator.js';
 import { chunkNode, characterChunk } from './chunker.js';
 import { extractStructuralNames } from './structural-extractor.js';
-import { DEFAULT_EMBEDDING_CONFIG, EMBEDDABLE_LABELS, isShortLabel, LABEL_METHOD, LABELS_WITH_EXPORTED, STRUCTURAL_LABELS, collectBestChunks, } from './types.js';
+import { EMBEDDABLE_LABELS, isShortLabel, LABEL_METHOD, LABELS_WITH_EXPORTED, STRUCTURAL_LABELS, collectBestChunks, } from './types.js';
+import { resolveEmbeddingConfig } from './config.js';
+import { rankExactEmbeddingRows } from './exact-search.js';
 import { EMBEDDING_TABLE_NAME, EMBEDDING_INDEX_NAME, CREATE_VECTOR_INDEX_QUERY, STALE_HASH_SENTINEL, } from '../lbug/schema.js';
 import { loadVectorExtension } from '../lbug/lbug-adapter.js';
+import { getExactScanLimit } from '../platform/capabilities.js';
 const isDev = process.env.NODE_ENV === 'development';
+const vectorUnavailableMessage = 'VECTOR extension is unavailable for this LadybugDB runtime; semantic search will use exact scan when embeddings exist.';
+const ensureVectorExtensionAvailable = async () => {
+    const vectorReady = await loadVectorExtension();
+    if (!vectorReady) {
+        return false;
+    }
+    return true;
+};
 /**
  * Bump this when the embedding text template changes in a way that should
  * invalidate existing vectors, such as metadata/header shape changes,
@@ -132,15 +143,17 @@ export const batchInsertEmbeddings = async (executeWithReusedStatement, updates)
 
  */
 const createVectorIndex = async (executeQuery) => {
-    // Delegate to the adapter which tracks loaded state and handles DB reconnect resets
-    await loadVectorExtension();
+    if (!(await ensureVectorExtensionAvailable()))
+        return false;
     try {
         await executeQuery(CREATE_VECTOR_INDEX_QUERY);
+        return true;
     }
     catch (error) {
         if (isDev) {
             console.warn('Vector index creation warning:', error);
         }
+        return false;
     }
 };
 /**
@@ -158,8 +171,12 @@ const createVectorIndex = async (executeQuery) => {
 
  */
 export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatement, onProgress, config = {}, skipNodeIds, context, existingEmbeddings) => {
-    const finalConfig = { ...DEFAULT_EMBEDDING_CONFIG, ...config };
+    const finalConfig = resolveEmbeddingConfig(config);
+    let totalChunks = 0;
     try {
+        const vectorAvailable = await ensureVectorExtensionAvailable();
+        if (!vectorAvailable && isDev)
+            console.warn(vectorUnavailableMessage);
         // Phase 1: Load embedding model
         onProgress({
             phase: 'loading-model',
@@ -247,21 +264,25 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
             // Ensure the vector index exists even when no new nodes need embedding.
             // A prior crash or first-time incremental run may have left CodeEmbedding
             // rows without ever reaching index creation.
-            await createVectorIndex(executeQuery);
+            const vectorIndexReady = await createVectorIndex(executeQuery);
             onProgress({
                 phase: 'ready',
                 percent: 100,
                 nodesProcessed: 0,
                 totalNodes: 0,
             });
-            return;
+            return {
+                nodesProcessed: 0,
+                chunksProcessed: 0,
+                vectorIndexReady,
+                semanticMode: vectorIndexReady ? 'vector-index' : 'exact-scan',
+            };
         }
         // Phase 3: Chunk + embed nodes
         const batchSize = finalConfig.batchSize;
         const chunkSize = finalConfig.chunkSize;
         const overlap = finalConfig.overlap;
         let processedNodes = 0;
-        let totalChunks = 0;
         onProgress({
             phase: 'embedding',
             percent: 20,
@@ -323,7 +344,7 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
                 }
             }
             // Embed chunk texts in sub-batches to control memory
-            const EMBED_SUB_BATCH = 8;
+            const EMBED_SUB_BATCH = finalConfig.subBatchSize;
             for (let si = 0; si < allTexts.length; si += EMBED_SUB_BATCH) {
                 const subTexts = allTexts.slice(si, si + EMBED_SUB_BATCH);
                 const subUpdates = allUpdates.slice(si, si + EMBED_SUB_BATCH);
@@ -363,7 +384,7 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
         if (isDev) {
             console.log('📇 Creating vector index...');
         }
-        await createVectorIndex(executeQuery);
+        const vectorIndexReady = await createVectorIndex(executeQuery);
         onProgress({
             phase: 'ready',
             percent: 100,
@@ -373,6 +394,12 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
         if (isDev) {
             console.log(`✅ Embedding pipeline complete! (${totalChunks} chunks from ${totalNodes} nodes)`);
         }
+        return {
+            nodesProcessed: totalNodes,
+            chunksProcessed: totalChunks,
+            vectorIndexReady,
+            semanticMode: vectorIndexReady ? 'vector-index' : 'exact-scan',
+        };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -397,26 +424,63 @@ export const semanticSearch = async (executeQuery, query, k = 10, maxDistance =
     const queryEmbedding = await embedText(query);
     const queryVec = embeddingToArray(queryEmbedding);
     const queryVecStr = `[${queryVec.join(',')}]`;
-    const bestChunks = await collectBestChunks(k, async (fetchLimit) => {
-        const vectorQuery = `
-      CALL QUERY_VECTOR_INDEX('${EMBEDDING_TABLE_NAME}', '${EMBEDDING_INDEX_NAME}',
-        CAST(${queryVecStr} AS FLOAT[${queryVec.length}]), ${fetchLimit})
-      YIELD node AS emb, distance
-      WITH emb, distance
-      WHERE distance < ${maxDistance}
-      RETURN emb.nodeId AS nodeId, emb.chunkIndex AS chunkIndex,
-             emb.startLine AS startLine, emb.endLine AS endLine, distance
-      ORDER BY distance
-    `;
-        const embResults = await executeQuery(vectorQuery);
-        return embResults.map((row) => ({
-            nodeId: row.nodeId ?? row[0],
-            chunkIndex: row.chunkIndex ?? row[1] ?? 0,
-            startLine: row.startLine ?? row[2] ?? 0,
-            endLine: row.endLine ?? row[3] ?? 0,
-            distance: row.distance ?? row[4],
-        }));
-    });
+    let bestChunks = new Map();
+    if (await loadVectorExtension()) {
+        try {
+            bestChunks = await collectBestChunks(k, async (fetchLimit) => {
+                const vectorQuery = `
+          CALL QUERY_VECTOR_INDEX('${EMBEDDING_TABLE_NAME}', '${EMBEDDING_INDEX_NAME}',
+            CAST(${queryVecStr} AS FLOAT[${queryVec.length}]), ${fetchLimit})
+          YIELD node AS emb, distance
+          WITH emb, distance
+          WHERE distance < ${maxDistance}
+          RETURN emb.nodeId AS nodeId, emb.chunkIndex AS chunkIndex,
+                 emb.startLine AS startLine, emb.endLine AS endLine, distance
+          ORDER BY distance
+        `;
+                const embResults = await executeQuery(vectorQuery);
+                return embResults.map((row) => ({
+                    nodeId: row.nodeId ?? row[0],
+                    chunkIndex: row.chunkIndex ?? row[1] ?? 0,
+                    startLine: row.startLine ?? row[2] ?? 0,
+                    endLine: row.endLine ?? row[3] ?? 0,
+                    distance: row.distance ?? row[4],
+                }));
+            });
+        }
+        catch {
+            bestChunks = new Map();
+        }
+    }
+    if (bestChunks.size === 0) {
+        const countRows = await executeQuery(`MATCH (e:${EMBEDDING_TABLE_NAME}) RETURN count(e) AS cnt`);
+        const countRow = countRows[0];
+        const embeddingCount = Number(countRow?.cnt ?? countRow?.[0] ?? 0);
+        const exactLimit = getExactScanLimit();
+        if (embeddingCount > 0 && embeddingCount <= exactLimit) {
+            const rows = await executeQuery(`
+        MATCH (e:${EMBEDDING_TABLE_NAME})
+        RETURN e.nodeId AS nodeId, e.chunkIndex AS chunkIndex,
+               e.startLine AS startLine, e.endLine AS endLine, e.embedding AS embedding
+      `);
+            const exactRows = rows.map((row) => ({
+                nodeId: row.nodeId ?? row[0],
+                chunkIndex: row.chunkIndex ?? row[1] ?? 0,
+                startLine: row.startLine ?? row[2] ?? 0,
+                endLine: row.endLine ?? row[3] ?? 0,
+                embedding: row.embedding ?? row[4] ?? [],
+            }));
+            bestChunks = new Map(rankExactEmbeddingRows(exactRows, queryVec, k, maxDistance).map((row) => [
+                row.nodeId,
+                {
+                    distance: row.distance,
+                    chunkIndex: row.chunkIndex,
+                    startLine: row.startLine,
+                    endLine: row.endLine,
+                },
+            ]));
+        }
+    }
     if (bestChunks.size === 0) {
         return [];
     }

package/dist/core/embeddings/exact-search.d.ts

@@ -0,0 +1,15 @@
+export interface ExactEmbeddingRow {
+    nodeId: string;
+    chunkIndex: number;
+    startLine: number;
+    endLine: number;
+    embedding: readonly number[];
+}
+export interface ExactSearchChunk {
+    nodeId: string;
+    chunkIndex: number;
+    startLine: number;
+    endLine: number;
+    distance: number;
+}
+export declare const rankExactEmbeddingRows: (rows: readonly ExactEmbeddingRow[], queryEmbedding: readonly number[], limit: number, maxDistance: number) => ExactSearchChunk[];

package/dist/core/embeddings/exact-search.js

@@ -0,0 +1,27 @@
+const cosineDistance = (a, b) => {
+    let dot = 0;
+    let aNorm = 0;
+    let bNorm = 0;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        const av = a[i] ?? 0;
+        const bv = b[i] ?? 0;
+        dot += av * bv;
+        aNorm += av * av;
+        bNorm += bv * bv;
+    }
+    if (aNorm === 0 || bNorm === 0)
+        return 1;
+    return 1 - dot / (Math.sqrt(aNorm) * Math.sqrt(bNorm));
+};
+export const rankExactEmbeddingRows = (rows, queryEmbedding, limit, maxDistance) => rows
+    .map((row) => ({
+    nodeId: row.nodeId,
+    chunkIndex: row.chunkIndex,
+    startLine: row.startLine,
+    endLine: row.endLine,
+    distance: cosineDistance(row.embedding, queryEmbedding),
+}))
+    .filter((row) => row.distance < maxDistance)
+    .sort((a, b) => a.distance - b.distance)
+    .slice(0, limit);

package/dist/core/embeddings/types.d.ts

@@ -102,6 +102,10 @@ export interface EmbeddingConfig {
     modelId: string;
     /** Number of nodes to embed in each batch */
     batchSize: number;
+    /** Number of chunks passed to one local/HTTP embedding call */
+    subBatchSize: number;
+    /** Maximum ONNX Runtime CPU threads for local inference */
+    threads: number;
     /** Embedding vector dimensions */
     dimensions: number;
     /** Device to use for inference: 'auto' tries GPU first (DirectML on Windows, CUDA on Linux), falls back to CPU */

package/dist/core/embeddings/types.js

@@ -147,6 +147,8 @@ export const CHUNKING_RULES = {
 export const DEFAULT_EMBEDDING_CONFIG = {
     modelId: 'Snowflake/snowflake-arctic-embed-xs',
     batchSize: 16,
+    subBatchSize: 8,
+    threads: 2,
     dimensions: 384,
     device: 'auto',
     maxSnippetLength: 500,

package/dist/core/group/config-parser.js

@@ -14,6 +14,8 @@ const DEFAULT_MATCHING = {
     bm25_threshold: 0.7,
     embedding_threshold: 0.65,
     max_candidates_per_step: 3,
+    exclude_links_paths: [],
+    exclude_links_param_only_paths: false,
 };
 export function parseGroupConfig(yamlContent) {
     const raw = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA });

package/dist/core/group/matching.d.ts

@@ -1,4 +1,4 @@
-import type { StoredContract, CrossLink } from './types.js';
+import type { StoredContract, CrossLink, MatchingConfig } from './types.js';
 export interface MatchResult {
     matched: CrossLink[];
     unmatched: StoredContract[];
@@ -8,6 +8,6 @@ export interface WildcardMatchResult {
     remaining: StoredContract[];
 }
 export declare function normalizeContractId(id: string): string;
-export declare function buildProviderIndex(contracts: StoredContract[]): Map<string, StoredContract[]>;
-export declare function runExactMatch(contracts: StoredContract[], providerIndex?: Map<string, StoredContract[]>): MatchResult;
+export declare function buildProviderIndex(contracts: StoredContract[], matchingConfig?: MatchingConfig): Map<string, StoredContract[]>;
+export declare function runExactMatch(contracts: StoredContract[], providerIndex?: Map<string, StoredContract[]>, matchingConfig?: MatchingConfig): MatchResult;
 export declare function runWildcardMatch(unmatched: StoredContract[], providerIndex: Map<string, StoredContract[]>): WildcardMatchResult;

package/dist/core/group/matching.js

@@ -1,6 +1,43 @@
 function isGrpcWildcard(cid) {
     return cid.startsWith('grpc::') && cid.endsWith('/*');
 }
+/**
+ * Detect HTTP contracts that are too generic or infrastructure-level to
+ * produce meaningful cross-repo links. These are still extracted (useful
+ * for documentation / route maps) but excluded from cross-link matching.
+ *
+ * Two categories:
+ * 1. Health-check / readiness endpoints — every service has one, matching
+ *    them produces N×M false links.
+ * 2. Param-only paths — routes like `/{param}` or `/{param}/{param}` that
+ *    collapse to a single catch-all after normalization. These match any
+ *    service with a similar shape, producing false positives.
+ *
+ * Both are configurable via matching.exclude_links_paths and
+ * matching.exclude_links_param_only_paths in group.yaml.
+ */
+function buildNoisyContractFilter(matchingConfig) {
+    const excludePaths = matchingConfig?.exclude_links_paths?.length
+        ? new Set(matchingConfig.exclude_links_paths.map((p) => p.replace(/\/+$/, '')))
+        : new Set();
+    const excludeParamOnly = matchingConfig?.exclude_links_param_only_paths === true;
+    return function isNoisyHttpContract(contractId) {
+        if (!contractId.startsWith('http::'))
+            return false;
+        const parts = contractId.split('::');
+        if (parts.length < 3)
+            return false;
+        const pathPart = parts.slice(2).join('::').replace(/\/+$/, '');
+        if (excludePaths.has(pathPart))
+            return true;
+        if (excludeParamOnly) {
+            const segments = pathPart.split('/').filter(Boolean);
+            if (segments.length > 0 && segments.every((s) => s === '{param}'))
+                return true;
+        }
+        return false;
+    };
+}
 export function normalizeContractId(id) {
     const colonIdx = id.indexOf('::');
     if (colonIdx === -1)
@@ -74,8 +111,9 @@ function findMatchingKeys(contractId, index) {
     }
     return [];
 }
-export function buildProviderIndex(contracts) {
-    const providers = contracts.filter((c) => c.role === 'provider');
+export function buildProviderIndex(contracts, matchingConfig) {
+    const isNoisy = buildNoisyContractFilter(matchingConfig);
+    const providers = contracts.filter((c) => c.role === 'provider' && !isNoisy(c.contractId));
     const index = new Map();
     for (const p of providers) {
         const key = normalizeContractId(p.contractId);
@@ -85,10 +123,10 @@ export function buildProviderIndex(contracts) {
     }
     return index;
 }
-export function runExactMatch(contracts, providerIndex) {
-    const index = providerIndex ?? buildProviderIndex(contracts);
-    // Skip gRPC wildcard consumers — they go to wildcard pass only
-    const consumers = contracts.filter((c) => c.role === 'consumer' && !isGrpcWildcard(c.contractId));
+export function runExactMatch(contracts, providerIndex, matchingConfig) {
+    const isNoisy = buildNoisyContractFilter(matchingConfig);
+    const index = providerIndex ?? buildProviderIndex(contracts, matchingConfig);
+    const consumers = contracts.filter((c) => c.role === 'consumer' && !isGrpcWildcard(c.contractId) && !isNoisy(c.contractId));
     const matched = [];
     const matchedConsumerIds = new Set();
     const matchedProviderIds = new Set();
@@ -129,6 +167,8 @@ export function runExactMatch(contracts, providerIndex) {
     const normalUnmatched = contracts.filter((c) => {
         if (isGrpcWildcard(c.contractId))
             return false; // excluded from exact, handled separately
+        if (isNoisy(c.contractId))
+            return false; // excluded from matching — don't surface as unmatched
         const id = `${c.repo}::${c.contractId}`;
         return c.role === 'provider' ? !matchedProviderIds.has(id) : !matchedConsumerIds.has(id);
     });

package/dist/core/group/storage.js

@@ -85,6 +85,8 @@ matching:
   bm25_threshold: 0.7
   embedding_threshold: 0.65
   max_candidates_per_step: 3
+  # exclude_links_paths: [/ping, /health, /healthcheck]
+  # exclude_links_param_only_paths: false
 `;
     await fsp.writeFile(path.join(groupDir, 'group.yaml'), template, 'utf-8');
     return groupDir;

package/dist/core/group/sync.js

@@ -168,7 +168,7 @@ export async function syncGroup(config, opts) {
             console.log(`  manifest: ${manifestCrossLinks.length} cross-links from ${config.links.length} declared links`);
         }
     }
-    const { matched, unmatched } = runExactMatch(autoContracts);
+    const { matched, unmatched } = runExactMatch(autoContracts, undefined, config.matching);
     // Dedupe cross-links. Manifest contracts participate in runExactMatch, so a
     // manifest-declared link can also emit a matchType:'exact' CrossLink with the
     // same endpoints. Prefer the manifest version — it reflects operator intent

package/dist/core/group/types.d.ts

@@ -29,6 +29,24 @@ export interface MatchingConfig {
     bm25_threshold: number;
     embedding_threshold: number;
     max_candidates_per_step: number;
+    /**
+     * HTTP paths to exclude from cross-link matching. Contracts at these paths
+     * are still extracted and visible in the registry, but they don't produce
+     * cross-repo links. Useful for health-check endpoints (`/ping`, `/health`)
+     * that every service exposes and would otherwise create N×M false links.
+     * Trailing slashes are normalized before comparison.
+     * @default []
+     */
+    exclude_links_paths?: string[];
+    /**
+     * When `true`, exclude HTTP routes where every path segment is `{param}`
+     * (e.g. `/{param}`, `/{param}/{param}`) from cross-link matching. Mixed
+     * routes like `/users/{param}` are not affected. These param-only routes
+     * collapse to a single catch-all after normalization and produce false
+     * positives across unrelated services.
+     * @default false
+     */
+    exclude_links_param_only_paths?: boolean;
 }
 export interface SymbolRef {
     filePath: string;

package/dist/core/ingestion/call-processor.d.ts

@@ -130,9 +130,9 @@ export declare const resolveMemberCall: (ownerType: string, methodName: string,
  * resolution via `ctx.resolve()`.
  *
  * Used for `foo()`, `doStuff()` — unqualified calls with no receiver.
- * Also handles Swift/Kotlin implicit constructors (`User()` without `new`)
- * by delegating to {@link resolveStaticCall} when the tiered pool contains
- * class-like targets.
+ * Also handles implicit constructors (`User()` without `new`) by delegating
+ * to {@link resolveStaticCall} when the tiered pool contains class-like
+ * targets.
  *
  * {@link resolveCallTarget} delegates here for `callForm === 'free'`.
  *

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

@@ -3,7 +3,7 @@ import { CLASS_TYPES, CALL_TARGET_TYPES, lookupMethodByOwnerWithMRO } from './mo
  * DAG stage 4 fallback: used when `selectDispatch` is absent or returns null.
  * Preserves pre-DAG dispatch semantics:
  *   - 'constructor'         → constructor branch
- *   - 'free'                → free branch (admits Swift/Kotlin class-target fast path)
+ *   - 'free'                → free branch (admits class-target fast path)
  *   - 'member' or undefined → owner-scoped branch
  *
  * `undefined` callForm MUST route through owner-scoped (not free) so bare
@@ -613,7 +613,7 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         if (!tree) {
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch (parseError) {
@@ -1275,41 +1275,19 @@ const disambiguateByOverloadOrArgTypes = (pool, overloadHints, preComputedArgTyp
         return matchCandidatesByArgTypes(pool, preComputedArgTypes);
     return null;
 };
-/**
- * Collapse Swift-extension duplicate Class/Struct candidates to the primary
- * definition, preferring the shortest file path.
- *
- * Swift extensions (`extension User { ... }` in a separate file) create
- * multiple `Class` nodes sharing the same symbol name — one for the primary
- * declaration and one per extension file. When overload disambiguation and
- * receiver narrowing both fail to converge on a single candidate, this
- * heuristic picks the primary definition based on the assumption that it
- * lives at the shortest file path (e.g. `User.swift` over `UserExtensions.swift`).
- *
- * Intentionally narrower than {@link INSTANTIABLE_CLASS_TYPES}: only `Class`
- * and `Struct` are considered, not `Record`. Swift extensions only produce
- * `Class` duplicates in practice, and C#/Kotlin records do not exhibit the
- * same multi-file-definition pattern, so widening this set risks accidental
- * dedup of legitimately distinct record types.
- *
- * Returns a `ResolveResult` when the heuristic fires, `null` when the
- * candidate pool does not match the shape (mixed types, non-Class/Struct
- * kinds, or `length <= 1`). Callers should fall through to their own null
- * return when this helper returns `null`.
- *
- * Used by `resolveFreeCall`. Having a single source of truth prevents
- * duplication if the heuristic is ever tuned.
- */
-const dedupSwiftExtensionCandidates = (candidates, tier) => {
-    if (candidates.length <= 1)
-        return null;
-    const allSameType = candidates.every((c) => c.type === candidates[0].type);
-    if (!allSameType)
-        return null;
-    if (candidates[0].type !== 'Class' && candidates[0].type !== 'Struct')
+const orderProviderSameNameTypeCandidates = (candidates, typeName, filePath) => {
+    const language = getLanguageFromFilename(filePath);
+    if (language == null)
         return null;
-    const sorted = [...candidates].sort((a, b) => a.filePath.length - b.filePath.length);
-    return toResolveResult(sorted[0], tier);
+    return (getProvider(language).orderSameNameTypeCandidates?.({
+        typeName,
+        callSiteFilePath: filePath,
+        candidates,
+    }) ?? null);
+};
+const resolveProviderPrimaryTypeCandidate = (candidates, tier, typeName, filePath) => {
+    const ordered = orderProviderSameNameTypeCandidates(candidates, typeName, filePath);
+    return ordered && ordered.length > 0 ? toResolveResult(ordered[0], tier) : null;
 };
 /**
  * Thin dispatcher that routes a call to the appropriate specialized resolver.
@@ -1742,6 +1720,25 @@ ancestryView) => {
             break;
         }
     }
+    if (!firstDef && !ambiguous) {
+        const orderedTypeCandidates = orderProviderSameNameTypeCandidates(ctx.model.types.lookupClassByName(receiverTypeName), receiverTypeName, filePath);
+        if (orderedTypeCandidates) {
+            for (const candidate of orderedTypeCandidates) {
+                const def = canWalkMRO
+                    ? lookupMethodByOwnerWithMRO(candidate.nodeId, methodName, heritageMap, ctx.model, mroStrategy, argCount)
+                    : ctx.model.methods.lookupMethodByOwner(candidate.nodeId, methodName, argCount);
+                if (!def)
+                    continue;
+                if (!firstDef) {
+                    firstDef = def;
+                }
+                else if (def.nodeId !== firstDef.nodeId) {
+                    ambiguous = true;
+                    break;
+                }
+            }
+        }
+    }
     if (!firstDef || ambiguous)
         return undefined;
     return { def: firstDef, tier: typeResolved.tier };
@@ -1791,9 +1788,9 @@ export const resolveMemberCall = (ownerType, methodName, currentFile, ctx, herit
  * resolution via `ctx.resolve()`.
  *
  * Used for `foo()`, `doStuff()` — unqualified calls with no receiver.
- * Also handles Swift/Kotlin implicit constructors (`User()` without `new`)
- * by delegating to {@link resolveStaticCall} when the tiered pool contains
- * class-like targets.
+ * Also handles implicit constructors (`User()` without `new`) by delegating
+ * to {@link resolveStaticCall} when the tiered pool contains class-like
+ * targets.
  *
  * {@link resolveCallTarget} delegates here for `callForm === 'free'`.
  *
@@ -1816,33 +1813,30 @@ export const resolveFreeCall = (calledName, filePath, ctx, argCount, tieredOverr
     if (!tiered)
         return null;
     let filteredCandidates = filterCallableCandidates(tiered.candidates, argCount, 'free');
-    // Class-target fast path: Swift/Kotlin `User()` — free-form call targeting a
-    // class. Delegates to resolveStaticCall for O(1) class + constructor lookup.
+    // Class-target fast path: free-form call targeting a class. Delegates to
+    // resolveStaticCall for O(1) class + constructor lookup.
     // The `.some()` trigger must stay aligned with `INSTANTIABLE_CLASS_TYPES` —
     // any type admitted here that is not in that set will cause resolveStaticCall
     // to return null, wasting two lookup passes per call. `Enum` is deliberately
-    // excluded; `Record` is included so C# records and Kotlin data classes reach
-    // the fast path.
+    // excluded; `Record` is included so record-like class targets reach the fast
+    // path.
     // Align with INSTANTIABLE_CLASS_TYPES by reusing the set directly rather
     // than enumerating literal strings. This converts an invariant that was
     // previously enforced by a comment ("keep this list aligned with
     // INSTANTIABLE_CLASS_TYPES") into one enforced structurally — any future
-    // extension of the set (e.g. Kotlin `object`) propagates here automatically.
-    // The `dedupSwiftExtensionCandidates` helper used in the tail of this
-    // function deliberately uses a narrower literal `'Class' | 'Struct'` check
-    // — Swift extensions only produce Class duplicates in practice, so Record
-    // is excluded there by design. Do not collapse that helper into
-    // INSTANTIABLE_CLASS_TYPES.
+    // extension of the set propagates here automatically.
+    // Language providers can still choose a primary same-name type candidate in
+    // the tail of this function when their grammars index one logical type
+    // multiple times.
     const hasClassTarget = filteredCandidates.length === 0 &&
         tiered.candidates.some((c) => INSTANTIABLE_CLASS_TYPES.has(c.type));
     if (hasClassTarget) {
         const staticResult = resolveStaticCall(calledName, filePath, ctx, argCount, tiered);
         if (staticResult)
             return staticResult;
-        // Retry with constructor form: Swift/Kotlin constructor calls look like
-        // free function calls (no `new` keyword). If resolveStaticCall didn't
-        // match, re-filter with constructor form so CONSTRUCTOR_TARGET_TYPES
-        // applies.
+        // Retry with constructor form for languages whose constructor calls look
+        // like free function calls. If resolveStaticCall didn't match, re-filter
+        // with constructor form so CONSTRUCTOR_TARGET_TYPES applies.
         //
         // The retry fires for every null return from `resolveStaticCall`, which
         // can happen for three distinct reasons — all three are handled below:
@@ -1856,9 +1850,8 @@ export const resolveFreeCall = (calledName, filePath, ctx, argCount, tieredOverr
         //   (b) Homonym ambiguity — two or more instantiable class candidates
         //       share the name (e.g. `User` in two files, same tier). The
         //       retry repopulates `filteredCandidates` with both Classes and
-        //       they flow into `dedupSwiftExtensionCandidates` below, which
-        //       either picks the shortest-path primary or null-routes.
-        //       Covered by the R7 Swift-extension dedup test.
+        //       they flow into the provider same-name candidate hook below, which
+        //       can pick a primary definition or null-route.
         //
         //   (c) `resolveStaticCall` step 4 bailed because the tiered pool
         //       contains ownerless `Constructor` nodes (some extractors emit
@@ -1882,11 +1875,9 @@ export const resolveFreeCall = (calledName, filePath, ctx, argCount, tieredOverr
             return toResolveResult(disambiguated, tiered.tier);
     }
     if (filteredCandidates.length !== 1) {
-        // See `dedupSwiftExtensionCandidates` — shared helper, single source of
-        // truth for the Swift-extension same-name collision heuristic.
-        const deduped = dedupSwiftExtensionCandidates(filteredCandidates, tiered.tier);
-        if (deduped)
-            return deduped;
+        const primary = resolveProviderPrimaryTypeCandidate(filteredCandidates, tiered.tier, calledName, filePath);
+        if (primary)
+            return primary;
         return null;
     }
     return toResolveResult(filteredCandidates[0], tiered.tier);
@@ -2034,9 +2025,11 @@ export const resolveStaticCall = (className, currentFile, ctx, argCount, tieredO
     //     Interface / Trait / Impl). Null-route via the fall-through `return
     //     null` — this is the dominant Codex-fix case.
     //   length === 1 → a single instantiable candidate remains, return it.
-    //   length  >  1 → two or more instantiable classes share the name (e.g.
-    //     homonym classes across files with no import narrowing). Fall through
-    //     to `return null` so the caller null-routes rather than guess.
+    //   length  >  1 → let the call-site provider choose a primary when it can
+    //     prove the candidates are one logical type; otherwise null-route.
+    const primary = resolveProviderPrimaryTypeCandidate(instantiableCandidates, typeResolved.tier, className, currentFile);
+    if (primary)
+        return primary;
     if (instantiableCandidates.length === 1) {
         return toResolveResult(instantiableCandidates[0], typeResolved.tier);
     }
@@ -2591,7 +2584,7 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
         if (!tree) {
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch {

package/dist/core/ingestion/constants.d.ts

@@ -10,7 +10,8 @@ export declare const TREE_SITTER_BUFFER_SIZE: number;
 export declare const TREE_SITTER_MAX_BUFFER: number;
 /**
  * Compute adaptive buffer size for tree-sitter parsing.
- * Uses 2× file size, clamped between 512 KB and 32 MB.
- * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
+ * Uses 2x UTF-8 byte size, clamped between 512 KB and 32 MB.
+ * Keeps tree-sitter's byte-sized buffer above large ASCII and multibyte sources.
  */
-export declare const getTreeSitterBufferSize: (contentLength: number) => number;
+export declare const getTreeSitterContentByteLength: (sourceText: string) => number;
+export declare const getTreeSitterBufferSize: (sourceText: string) => number;