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

package/dist/core/ingestion/constants.js

@@ -1,3 +1,4 @@
+import { Buffer } from 'node:buffer';
 /**
  * Default minimum buffer size for tree-sitter parsing (512 KB).
  * tree-sitter requires bufferSize >= file size in bytes.
@@ -10,7 +11,11 @@ export const TREE_SITTER_BUFFER_SIZE = 512 * 1024;
 export const TREE_SITTER_MAX_BUFFER = 32 * 1024 * 1024;
 /**
  * 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 const getTreeSitterBufferSize = (contentLength) => Math.min(Math.max(contentLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER);
+export const getTreeSitterContentByteLength = (sourceText) => Buffer.byteLength(sourceText, 'utf8');
+export const getTreeSitterBufferSize = (sourceText) => {
+    const byteLength = getTreeSitterContentByteLength(sourceText);
+    return Math.min(Math.max(byteLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER);
+};

package/dist/core/ingestion/finalize-orchestrator.js

@@ -58,7 +58,7 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
     const allScopes = [];
     const allDefs = [];
     const moduleEntries = [];
-    const allReferenceSites = [];
+    const allReferenceSites = collectReferenceSites(parsedFiles);
     for (const file of parsedFiles) {
         for (const s of file.scopes)
             allScopes.push(s);
@@ -66,8 +66,6 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
             allDefs.push(d);
         moduleEntries.push({ filePath: file.filePath, moduleScopeId: file.moduleScope });
     }
-    // References kept out of the loop above to centralize list-init.
-    allReferenceSites.push(...collectReferenceSites(parsedFiles));
     const scopeTree = buildScopeTree(allScopes);
     const defs = buildDefIndex(allDefs);
     const qualifiedNames = buildQualifiedNameIndex(allDefs);
@@ -91,6 +89,11 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
         methodDispatch,
         imports: finalizeOut.imports,
         bindings: finalizeOut.bindings,
+        // Empty post-finalize augmentation channel. Populated (if at all)
+        // by language hooks like `populateCsharpNamespaceSiblings` running
+        // AFTER `finalizeScopeModel` returns, before `resolveReferenceSites`
+        // consumes the bundle. Most languages leave it empty.
+        bindingAugmentations: new Map(),
         referenceSites: Object.freeze([...allReferenceSites]),
         sccs: finalizeOut.sccs,
         stats: finalizeOut.stats,

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

@@ -148,7 +148,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             // Use larger bufferSize for files > 32KB
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch (parseError) {
@@ -295,7 +295,7 @@ export async function extractExtractedHeritageFromFiles(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/import-processor.js

@@ -242,7 +242,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         if (!tree) {
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch (parseError) {

package/dist/core/ingestion/language-provider.d.ts

@@ -382,6 +382,14 @@ interface LanguageProviderConfig {
      * else treats as `'free'`).
      */
     readonly classifyCallForm?: (captures: CaptureMatch, enclosingScope: Scope) => 'free' | 'member' | 'constructor' | 'index';
+    /** Order same-name type candidates when a language can index multiple
+     * definitions for one logical type. Return null to keep shared ambiguity
+     * handling. */
+    readonly orderSameNameTypeCandidates?: (params: {
+        readonly typeName: string;
+        readonly callSiteFilePath: string;
+        readonly candidates: readonly SymbolDefinition[];
+    }) => readonly SymbolDefinition[] | null;
     /**
      * Is this callable definition compatible with the given call-site arity?
      * Language-specific rules: Python `*args`/`**kwargs`/defaults, JS default

package/dist/core/ingestion/languages/csharp/captures.js

@@ -21,6 +21,7 @@ import { computeCsharpArityMetadata } from './arity-metadata.js';
 import { synthesizeCsharpReceiverBinding } from './receiver-binding.js';
 import { getCsharpParser, getCsharpScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = [
     '@declaration.method',
@@ -43,7 +44,9 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
     // the LanguageProvider contract layer; cast here at the use site.
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = getCsharpParser().parse(sourceText);
+        tree = getCsharpParser().parse(sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
         recordCacheMiss();
     }
     else {

package/dist/core/ingestion/languages/csharp/namespace-siblings.d.ts

@@ -11,17 +11,18 @@
  * field-chain resolution fails at `findClassBindingInScope('User')`
  * in the Service.cs scope chain.
  *
- * Implementation: after the finalize pass populates `indexes.bindings`
- * (from explicit `using` directives), walk each file's tree-sitter
- * AST for `namespace_declaration` / `file_scoped_namespace_declaration`
- * and `using_directive` nodes. The orchestrator hands us its
- * `treeCache` so files already parsed by `extractParsedFile` are
- * re-used instead of re-parsed — `ParsedFile`'s underlying tree is
- * the single source of truth. Group classes by namespace, and inject
- * cross-file sibling classes into each Namespace scope's finalized
- * bindings with `origin: 'namespace'` — a tier below `local` so a
- * local declaration still shadows a cross-file sibling with the same
- * name.
+ * Implementation: after the finalize pass populates immutable
+ * `indexes.bindings` (from explicit `using` directives), walk each
+ * file's tree-sitter AST for `namespace_declaration` /
+ * `file_scoped_namespace_declaration` and `using_directive` nodes.
+ * The orchestrator hands us its `treeCache` so files already parsed
+ * by `extractParsedFile` are re-used instead of re-parsed —
+ * `ParsedFile`'s underlying tree is the single source of truth.
+ * Group classes by namespace, and append cross-file sibling classes
+ * into each Namespace scope's `bindingAugmentations` bucket with
+ * `origin: 'namespace'`. Finalized bindings remain first in
+ * `lookupBindingsAt`, and local lexical `Scope.bindings` remains the
+ * first-tier shadowing channel.
  *
  * The tree-sitter walk is authoritative: it sees `global using static`,
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
@@ -42,8 +43,8 @@ export interface CsharpSiblingInputs {
     };
 }
 /**
- * Mutate `indexes.bindings` in-place, adding cross-file sibling class
- * defs to each Namespace scope. Class-like defs (Class / Interface /
+ * Append cross-file sibling class defs to each Namespace scope's
+ * `bindingAugmentations` bucket. Class-like defs (Class / Interface /
  * Struct / Record / Enum) are visible cross-file; method / field
  * members are not.
  */

package/dist/core/ingestion/languages/csharp/namespace-siblings.js

@@ -11,17 +11,18 @@
  * field-chain resolution fails at `findClassBindingInScope('User')`
  * in the Service.cs scope chain.
  *
- * Implementation: after the finalize pass populates `indexes.bindings`
- * (from explicit `using` directives), walk each file's tree-sitter
- * AST for `namespace_declaration` / `file_scoped_namespace_declaration`
- * and `using_directive` nodes. The orchestrator hands us its
- * `treeCache` so files already parsed by `extractParsedFile` are
- * re-used instead of re-parsed — `ParsedFile`'s underlying tree is
- * the single source of truth. Group classes by namespace, and inject
- * cross-file sibling classes into each Namespace scope's finalized
- * bindings with `origin: 'namespace'` — a tier below `local` so a
- * local declaration still shadows a cross-file sibling with the same
- * name.
+ * Implementation: after the finalize pass populates immutable
+ * `indexes.bindings` (from explicit `using` directives), walk each
+ * file's tree-sitter AST for `namespace_declaration` /
+ * `file_scoped_namespace_declaration` and `using_directive` nodes.
+ * The orchestrator hands us its `treeCache` so files already parsed
+ * by `extractParsedFile` are re-used instead of re-parsed —
+ * `ParsedFile`'s underlying tree is the single source of truth.
+ * Group classes by namespace, and append cross-file sibling classes
+ * into each Namespace scope's `bindingAugmentations` bucket with
+ * `origin: 'namespace'`. Finalized bindings remain first in
+ * `lookupBindingsAt`, and local lexical `Scope.bindings` remains the
+ * first-tier shadowing channel.
  *
  * The tree-sitter walk is authoritative: it sees `global using static`,
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
@@ -30,13 +31,17 @@
  * coincidences).
  */
 import { getCsharpParser } from './query.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
 /** Build a structural view of a C# file by walking the tree-sitter
  *  AST. Prefers `cachedTree` (handed in via `treeCache`) so we don't
  *  re-parse files the orchestrator already parsed for `extractParsedFile`;
  *  falls back to a fresh parse on cache miss. Parser singleton is
  *  shared across calls. */
 function extractFileStructure(content, cachedTree) {
-    const tree = cachedTree ?? getCsharpParser().parse(content);
+    const tree = cachedTree ??
+        getCsharpParser().parse(content, undefined, {
+            bufferSize: getTreeSitterBufferSize(content),
+        });
     const namespaces = [];
     const usingStaticPaths = [];
     const visit = (node) => {
@@ -81,8 +86,8 @@ function extractFileStructure(content, cachedTree) {
     return { namespaces, usingStaticPaths };
 }
 /**
- * Mutate `indexes.bindings` in-place, adding cross-file sibling class
- * defs to each Namespace scope. Class-like defs (Class / Interface /
+ * Append cross-file sibling class defs to each Namespace scope's
+ * `bindingAugmentations` bucket. Class-like defs (Class / Interface /
  * Struct / Record / Enum) are visible cross-file; method / field
  * members are not.
  */
@@ -161,12 +166,15 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             }
         }
     }
-    // Inject cross-file siblings into each namespace scope's finalized
-    // bindings. `indexes.bindings` is typed `ReadonlyMap<ScopeId, ...>`
-    // but is a plain Map at runtime; mutating here is the established
-    // pattern (see `propagateImportedReturnTypes` which does the same
-    // for module-scope typeBindings).
-    const finalized = indexes.bindings;
+    // Inject cross-file siblings into each namespace scope's
+    // post-finalize augmentation channel (per I8). The
+    // `indexes.bindingAugmentations` map is the dedicated mutable
+    // append-only buffer for post-finalize hooks: inner `BindingRef[]`
+    // arrays here are NEVER frozen (unlike `indexes.bindings`, which
+    // `materializeBindings` freezes). Walkers consult both channels
+    // via `lookupBindingsAt`; we never need to consult or mutate
+    // `indexes.bindings`.
+    const augmentations = indexes.bindingAugmentations;
     // Cross-namespace type-binding propagation: for each file, mirror
     // method return-type bindings from same-namespace sibling files and
     // from files in namespaces the importer `using`s, into the
@@ -268,18 +276,14 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 const simpleName = mq.includes('.') ? mq.slice(mq.lastIndexOf('.') + 1) : mq;
                 if (simpleName === '')
                     continue;
-                // Add to `indexes.bindings[moduleScope]` so
-                // `findCallableBindingInScope` picks it up.
-                let scopeBindings = finalized.get(moduleScope.id);
-                if (scopeBindings === undefined) {
-                    scopeBindings = new Map();
-                    finalized.set(moduleScope.id, scopeBindings);
-                }
-                const existing = scopeBindings.get(simpleName) ?? [];
-                if (existing.some((b) => b.def.nodeId === memberDef.nodeId))
+                // Append to the augmentation bucket for the importer's module
+                // scope. `findCallableBindingInScope` reads via
+                // `lookupBindingsAt`, which fans out across `bindings` +
+                // `bindingAugmentations`.
+                const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
+                if (bucketArr.some((b) => b.def.nodeId === memberDef.nodeId))
                     continue;
-                existing.push({ def: memberDef, origin: 'import' });
-                scopeBindings.set(simpleName, existing);
+                bucketArr.push({ def: memberDef, origin: 'import' });
             }
         }
     }
@@ -310,16 +314,10 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 const simpleName = q.includes('.') ? q.slice(q.lastIndexOf('.') + 1) : q;
                 if (simpleName === '')
                     continue;
-                let scopeBindings = finalized.get(moduleScope.id);
-                if (scopeBindings === undefined) {
-                    scopeBindings = new Map();
-                    finalized.set(moduleScope.id, scopeBindings);
-                }
-                const existing = scopeBindings.get(simpleName) ?? [];
-                if (existing.some((b) => b.def.nodeId === def.nodeId))
+                const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
+                if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
                     continue;
-                existing.push({ def, origin: 'namespace' });
-                scopeBindings.set(simpleName, existing);
+                bucketArr.push({ def, origin: 'namespace' });
             }
         }
     }
@@ -339,11 +337,6 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             defsByName.set(key, arr);
         }
         for (const { scopeId, filePath } of bucket.scopes) {
-            let scopeBindings = finalized.get(scopeId);
-            if (scopeBindings === undefined) {
-                scopeBindings = new Map();
-                finalized.set(scopeId, scopeBindings);
-            }
             for (const [name, defs] of defsByName) {
                 // Skip names already present locally — `origin: 'local'` in
                 // scope.bindings would naturally shadow the cross-file
@@ -351,20 +344,39 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 const local = bucket.scopes.find((s) => s.filePath === filePath)?.scope.bindings.get(name);
                 if (local !== undefined && local.some((b) => b.origin === 'local'))
                     continue;
-                const existing = scopeBindings.get(name) ?? [];
+                let bucketArr = null;
                 for (const def of defs) {
                     if (def.filePath === filePath)
                         continue; // don't self-reference
-                    if (existing.some((b) => b.def.nodeId === def.nodeId))
+                    if (bucketArr === null)
+                        bucketArr = getAugmentationBucket(augmentations, scopeId, name);
+                    if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
                         continue;
-                    existing.push({ def, origin: 'namespace' });
+                    bucketArr.push({ def, origin: 'namespace' });
                 }
-                if (existing.length > 0)
-                    scopeBindings.set(name, existing);
             }
         }
     }
 }
+/** Get-or-create a mutable inner bucket inside the `bindingAugmentations`
+ *  channel. The inner arrays here are mutable by contract (see
+ *  `ScopeResolutionIndexes.bindingAugmentations` doc + scope-resolver I8);
+ *  callers may `push` directly. Allocating the outer/inner Maps lazily
+ *  keeps the augmentation footprint zero for files with no cross-file
+ *  fanout. */
+function getAugmentationBucket(augmentations, scopeId, name) {
+    let scopeBindings = augmentations.get(scopeId);
+    if (scopeBindings === undefined) {
+        scopeBindings = new Map();
+        augmentations.set(scopeId, scopeBindings);
+    }
+    let bucketArr = scopeBindings.get(name);
+    if (bucketArr === undefined) {
+        bucketArr = [];
+        scopeBindings.set(name, bucketArr);
+    }
+    return bucketArr;
+}
 function isTypeDef(def) {
     return (def.type === 'Class' ||
         def.type === 'Interface' ||

package/dist/core/ingestion/languages/python/captures.js

@@ -21,6 +21,8 @@ import { getPythonParser, getPythonScopeQuery } from './query.js';
 import { synthesizeReceiverTypeBinding } from './receiver-binding.js';
 import { computePythonArityMetadata } from './arity-metadata.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
+import { pythonFunctionDefinitionLabel } from './simple-hooks.js';
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // Skip the parse when the caller (parse phase's ASTCache) already
     // produced a Tree for this source. Cache miss = re-parse, same as
@@ -29,7 +31,9 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // here at the use site.
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = getPythonParser().parse(sourceText);
+        tree = getPythonParser().parse(sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
         recordCacheMiss();
     }
     else {
@@ -83,6 +87,10 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
             const anchorCap = grouped['@declaration.function'];
             const fnNode = findNodeAtRange(tree.rootNode, anchorCap.range, 'function_definition');
             if (fnNode !== null) {
+                if (pythonFunctionDefinitionLabel(fnNode, 'Function') === 'Method') {
+                    delete grouped['@declaration.function'];
+                    grouped['@declaration.method'] = { ...anchorCap, name: '@declaration.method' };
+                }
                 const arity = computePythonArityMetadata(fnNode);
                 if (arity.parameterCount !== undefined) {
                     grouped['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', fnNode, String(arity.parameterCount));

package/dist/core/ingestion/languages/python/index.d.ts

@@ -77,4 +77,4 @@ export { interpretPythonImport, interpretPythonTypeBinding } from './interpret.j
 export { pythonMergeBindings } from './merge-bindings.js';
 export { pythonArityCompatibility } from './arity.js';
 export { resolvePythonImportTarget, type PythonResolveContext } from './import-target.js';
-export { pythonBindingScopeFor, pythonImportOwningScope, pythonReceiverBinding, } from './simple-hooks.js';
+export { pythonBindingScopeFor, pythonFunctionDefinitionLabel, pythonImportOwningScope, pythonReceiverBinding, } from './simple-hooks.js';

package/dist/core/ingestion/languages/python/index.js

@@ -77,4 +77,4 @@ export { interpretPythonImport, interpretPythonTypeBinding } from './interpret.j
 export { pythonMergeBindings } from './merge-bindings.js';
 export { pythonArityCompatibility } from './arity.js';
 export { resolvePythonImportTarget } from './import-target.js';
-export { pythonBindingScopeFor, pythonImportOwningScope, pythonReceiverBinding, } from './simple-hooks.js';
+export { pythonBindingScopeFor, pythonFunctionDefinitionLabel, pythonImportOwningScope, pythonReceiverBinding, } from './simple-hooks.js';

package/dist/core/ingestion/languages/python/simple-hooks.d.ts

@@ -5,7 +5,9 @@
  * "absence == default") so reviewers don't have to re-derive the
  * analysis.
  */
-import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+import type { CaptureMatch, NodeLabel, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+import type { SyntaxNode } from 'tree-sitter';
+export declare function pythonFunctionDefinitionLabel(functionNode: SyntaxNode, defaultLabel: NodeLabel): NodeLabel;
 /** Python has no block scope, so the central extractor's "innermost
  *  enclosing scope" default is already correct: `for x in …` creates
  *  `x` in the enclosing function/module scope (because we never emit a

package/dist/core/ingestion/languages/python/simple-hooks.js

@@ -5,6 +5,14 @@
  * "absence == default") so reviewers don't have to re-derive the
  * analysis.
  */
+import { findAncestorBeforeBoundary, FUNCTION_NODE_TYPES } from '../../utils/ast-helpers.js';
+const PYTHON_METHOD_CONTAINER_TYPES = new Set(['class_definition']);
+export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    const ancestor = findAncestorBeforeBoundary(functionNode, PYTHON_METHOD_CONTAINER_TYPES, FUNCTION_NODE_TYPES);
+    return ancestor === null ? 'Function' : 'Method';
+}
 // ─── bindingScopeFor ──────────────────────────────────────────────────────
 /** Python has no block scope, so the central extractor's "innermost
  *  enclosing scope" default is already correct: `for x in …` creates

package/dist/core/ingestion/languages/python.js

@@ -28,7 +28,7 @@ import { pythonVariableConfig } from '../variable-extractors/configs/python.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { pythonCallConfig } from '../call-extractors/configs/python.js';
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
-import { emitPythonScopeCaptures, interpretPythonImport, interpretPythonTypeBinding, pythonArityCompatibility, pythonBindingScopeFor, pythonImportOwningScope, pythonMergeBindings, pythonReceiverBinding, resolvePythonImportTarget, } from './python/index.js';
+import { emitPythonScopeCaptures, pythonFunctionDefinitionLabel, interpretPythonImport, interpretPythonTypeBinding, pythonArityCompatibility, pythonBindingScopeFor, pythonImportOwningScope, pythonMergeBindings, pythonReceiverBinding, resolvePythonImportTarget, } from './python/index.js';
 const BUILT_INS = new Set([
     'print',
     'len',
@@ -58,6 +58,31 @@ const BUILT_INS = new Set([
     'sum',
     'abs',
 ]);
+function pythonDescriptionExtractor(nodeLabel, _nodeName, captureMap) {
+    if (nodeLabel !== 'Function' && nodeLabel !== 'Method')
+        return undefined;
+    const functionNode = captureMap['definition.function'] ?? captureMap['definition.method'];
+    if (functionNode === undefined)
+        return undefined;
+    return extractPythonDocstring(functionNode);
+}
+function extractPythonDocstring(functionNode) {
+    const body = functionNode.childForFieldName('body');
+    const firstStatement = body?.namedChild(0);
+    if (firstStatement?.type !== 'expression_statement')
+        return undefined;
+    const literal = firstStatement.namedChild(0);
+    if (literal?.type !== 'string')
+        return undefined;
+    return normalizePythonStringLiteral(literal.text);
+}
+function normalizePythonStringLiteral(text) {
+    const match = text.match(/^[rRuUbBfF]*("""|'''|"|')([\s\S]*)\1$/);
+    const raw = match?.[2]?.trim();
+    if (!raw)
+        return undefined;
+    return raw.replace(/\s+/g, ' ');
+}
 export const pythonProvider = defineLanguage({
     id: SupportedLanguages.Python,
     extensions: ['.py'],
@@ -74,7 +99,9 @@ export const pythonProvider = defineLanguage({
     variableExtractor: createVariableExtractor(pythonVariableConfig),
     classExtractor: createClassExtractor(pythonClassConfig),
     heritageExtractor: createHeritageExtractor(SupportedLanguages.Python),
+    descriptionExtractor: pythonDescriptionExtractor,
     builtInNames: BUILT_INS,
+    labelOverride: pythonFunctionDefinitionLabel,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     // Python is the first migration. See ./python/index.ts for the
     // full per-hook rationale and the canonical capture vocabulary in

package/dist/core/ingestion/languages/swift.js

@@ -112,6 +112,19 @@ const swiftExtractFunctionName = (node) => {
         return { funcName: 'deinit', label: 'Constructor' };
     return null; // fall through to generic
 };
+const orderSwiftSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
+    if (!callSiteFilePath.endsWith('.swift'))
+        return null;
+    if (candidates.length <= 1)
+        return null;
+    if (!candidates.every((c) => c.type === candidates[0].type))
+        return null;
+    if (candidates[0].type !== 'Class' && candidates[0].type !== 'Struct')
+        return null;
+    if (!candidates.every((c) => c.filePath.endsWith('.swift')))
+        return null;
+    return [...candidates].sort((a, b) => a.filePath.length - b.filePath.length || a.filePath.localeCompare(b.filePath));
+};
 const BUILT_INS = new Set([
     'print',
     'debugPrint',
@@ -240,5 +253,6 @@ export const swiftProvider = defineLanguage({
     classExtractor: createClassExtractor(swiftClassConfig),
     heritageExtractor: createHeritageExtractor(SupportedLanguages.Swift),
     implicitImportWirer: wireSwiftImplicitImports,
+    orderSameNameTypeCandidates: orderSwiftSameNameTypeCandidates,
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/languages/typescript/arity-metadata.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Extract TypeScript arity metadata from a method-like tree-sitter node —
+ * `method_definition`, `method_signature`, `abstract_method_signature`,
+ * `function_declaration`, `generator_function_declaration`, or
+ * `function_signature` (overload signature).
+ *
+ * Reuses `typescriptMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - Rest parameters (`...args: T[]`) collapse `parameterCount` to
+ *     `undefined`, which `typescriptArityCompatibility` treats as
+ *     "max unknown" — the candidate stays eligible at
+ *     `argCount >= required` (mirrors Python `*args` / C# `params`).
+ *   - Optional (`p?: T`) and defaulted (`p: T = …`) parameters both
+ *     contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type-annotation text for
+ *     overload narrowing; TypeScript supports function overloading
+ *     (`function f(x: string); function f(x: number); function f(x) {}`),
+ *     so populated types let the registry disambiguate same-arity
+ *     siblings by declared types.
+ *   - A literal `'params'` marker is appended for variadic methods so
+ *     `typescriptArityCompatibility` can detect rest params without
+ *     re-reading the AST.
+ *
+ * ## Generics stripping
+ *
+ * TypeScript parameter types frequently contain generic instantiations
+ * (`User<string>`, `Array<User>`, `Promise<User[]>`). For overload
+ * narrowing by declared type, we want the "head" name — `User`,
+ * `Array`, `Promise` — so `arity-metadata` applies a light strip to
+ * each `parameterTypes[i]`:
+ *
+ *   - `Foo<Bar>`          → `Foo`
+ *   - `Foo<Bar, Baz>`     → `Foo`
+ *   - `Foo[]`             → `Foo`
+ *   - `Foo<Bar>[]`        → `Foo`
+ *   - `Foo<Bar<Baz>>`     → `Foo`   (greedy — strip the outermost once)
+ *   - plain `Foo`         → `Foo`
+ *
+ * We do NOT strip unions / intersections at this layer — those stay
+ * intact because the registry's overload narrowing is a string
+ * equality check; union types shouldn't match anything and we prefer
+ * "unknown" to "accidental match". `undefined` / `null` in unions
+ * (TS strict mode) is handled by `interpret.ts`'s `stripNullableUnion`
+ * when the name would be consumed as a receiver type — that path is
+ * separate from this arity-metadata path.
+ *
+ * Generic type parameters on the function itself (`function f<T>(x: T)`)
+ * do NOT enter here — the method extractor reads the `parameters`
+ * field only, which contains value parameters, not type parameters.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface TsArityMetadata {
+    readonly parameterCount: number | undefined;
+    readonly requiredParameterCount: number | undefined;
+    readonly parameterTypes: readonly string[] | undefined;
+}
+export declare function computeTsArityMetadata(fnNode: SyntaxNode): TsArityMetadata;
+export {};