gitnexus 1.6.6-rc.90 → 1.6.6-rc.92

package/dist/core/group/extractors/http-patterns/python.js

@@ -538,8 +538,9 @@ const HTTPX_ASYNC_CLIENT_GENERIC_PATTERNS = compilePatterns({
 });
 /** Strip `.py` and return the bare basename (e.g. `api/users.py` → `users`). */
 function fileShortKey(rel) {
-    const slash = rel.lastIndexOf('/');
-    const file = slash >= 0 ? rel.slice(slash + 1) : rel;
+    const normalized = rel.replace(/\\/g, '/');
+    const slash = normalized.lastIndexOf('/');
+    const file = slash >= 0 ? normalized.slice(slash + 1) : normalized;
     return file.endsWith('.py') ? file.slice(0, -3) : file;
 }
 /**
@@ -548,7 +549,8 @@ function fileShortKey(rel) {
  * case callers should fall back to the short key.
  */
 function fileLongKey(rel) {
-    const noExt = rel.endsWith('.py') ? rel.slice(0, -3) : rel;
+    const normalized = rel.replace(/\\/g, '/');
+    const noExt = normalized.endsWith('.py') ? normalized.slice(0, -3) : normalized;
     const lastSlash = noExt.lastIndexOf('/');
     if (lastSlash < 0)
         return '';

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

@@ -28,10 +28,38 @@
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
  * and preprocessor-guarded declarations correctly because the
  * tree-sitter grammar parses them as real nodes (not textual
- * coincidences).
+ * coincidences). When the orchestrator's `treeCache` has no Tree for a
+ * file — the worker path, where native Trees can't cross MessageChannels
+ * — `extractFileStructure` falls back to a line scanner rather than
+ * re-parsing every file from scratch (that re-parse dominated worker-mode
+ * scope-resolution time). See `extractCsharpStructureViaScanner`.
  */
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export interface CsharpFileStructure {
+    /** Declared namespace names in file source order. Empty array means
+     *  the file has no `namespace X;` / `namespace X { }` declaration
+     *  and sits in the default (global) namespace. */
+    readonly namespaces: readonly string[];
+    /** Dotted paths from `using static X.Y.Z;` (including
+     *  `global using static` and aliased `using static A = X.Y.Z;`). */
+    readonly usingStaticPaths: readonly string[];
+}
+/** Line-scanner used when no cached tree is available (worker-parsed files
+ *  can't transfer native tree-sitter Trees across MessageChannels, so
+ *  `treeCache` is empty for them). Re-parsing every C# file here with
+ *  tree-sitter was the dominant scope-resolution cost on large worker-mode
+ *  runs — for a multi-thousand-file solution this loop alone re-parsed the
+ *  whole repo a second time. The scanner extracts the same `namespaces` /
+ *  `usingStaticPaths` the AST walk produces for line-anchored declarations,
+ *  while tracking block-comment and string state across lines (via
+ *  `advanceCsScanState`) so a `namespace` / `using static` keyword at the
+ *  start of a line inside a block comment, verbatim string, or raw string
+ *  literal is NOT mistaken for a declaration. The remaining trade-off vs the
+ *  AST is a declaration whose keyword is not at the start of a code line
+ *  (split across lines, or sharing a line with a comment/string closer).
+ *  Mirrors PHP's `extractNamespaceViaScanner` (issue #1741). */
+export declare function extractCsharpStructureViaScanner(content: string): CsharpFileStructure;
 /** Content + (optional) pre-parsed tree-sitter trees keyed by filePath.
  *  The orchestrator builds `fileContents` from the pipeline's file list;
  *  `treeCache` is the same `scopeTreeCache` already populated by the

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

@@ -28,21 +28,188 @@
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
  * and preprocessor-guarded declarations correctly because the
  * tree-sitter grammar parses them as real nodes (not textual
- * coincidences).
+ * coincidences). When the orchestrator's `treeCache` has no Tree for a
+ * file — the worker path, where native Trees can't cross MessageChannels
+ * — `extractFileStructure` falls back to a line scanner rather than
+ * re-parsing every file from scratch (that re-parse dominated worker-mode
+ * scope-resolution time). See `extractCsharpStructureViaScanner`.
  */
-import { getCsharpParser } from './query.js';
-import { getTreeSitterBufferSize } from '../../constants.js';
-import { parseSourceSafe } from '../../../tree-sitter/safe-parse.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. */
+// Line-anchored matchers for the worker-path fallback (see
+// `extractCsharpStructureViaScanner`). Anchored at line start (after
+// indentation); the scanner additionally tracks block-comment / string
+// state across lines so a keyword at the start of a line inside one of
+// those regions is skipped.
+const CS_NAMESPACE_RE = /^[ \t]*namespace[ \t]+([A-Za-z_@][A-Za-z0-9_.]*)/;
+// `global using static`, plain `using static`, and the aliased
+// `using static Alias = NS.Type;` form (the AST keeps the RHS path, so
+// the optional `Alias =` is skipped and only the dotted path captured).
+const CS_USING_STATIC_RE = /^[ \t]*(?:global[ \t]+)?using[ \t]+static[ \t]+(?:[A-Za-z_@][A-Za-z0-9_]*[ \t]*=[ \t]*)?([A-Za-z_@][A-Za-z0-9_.]*)/;
+/** Advance the scanner's lexical state across one line, consuming block
+ *  comments (slash-star), line comments (`//`), single-line regular /
+ *  interpolated strings, verbatim strings (`@"…"`), and raw string literals
+ *  (`"""…"""`, fence length tracked in `rawFence`). Returns the state and
+ *  raw-fence length in effect at the START of the next line. Single-line
+ *  strings and `//` comments resolve back to `code` before end of line; only
+ *  block comments and multi-line strings carry state forward. */
+function advanceCsScanState(line, state, rawFence) {
+    const n = line.length;
+    let i = 0;
+    while (i < n) {
+        if (state === 'block') {
+            const end = line.indexOf('*/', i);
+            if (end === -1)
+                return ['block', rawFence];
+            i = end + 2;
+            state = 'code';
+        }
+        else if (state === 'verbatim') {
+            // Ends at a `"` that is not doubled (`""` is an escaped quote).
+            while (i < n) {
+                if (line[i] === '"') {
+                    if (line[i + 1] === '"') {
+                        i += 2;
+                        continue;
+                    }
+                    break;
+                }
+                i++;
+            }
+            if (i >= n)
+                return ['verbatim', rawFence];
+            i += 1;
+            state = 'code';
+        }
+        else if (state === 'raw') {
+            // Ends at a run of `"` at least `rawFence` long.
+            let closed = false;
+            while (i < n) {
+                if (line[i] === '"') {
+                    let k = i;
+                    while (k < n && line[k] === '"')
+                        k++;
+                    if (k - i >= rawFence) {
+                        i = k;
+                        state = 'code';
+                        rawFence = 0;
+                        closed = true;
+                        break;
+                    }
+                    i = k;
+                }
+                else {
+                    i++;
+                }
+            }
+            if (!closed)
+                return ['raw', rawFence];
+        }
+        else {
+            const c = line[i];
+            const next = line[i + 1];
+            if (c === '/' && next === '/')
+                return ['code', rawFence]; // line comment to EOL
+            if (c === '/' && next === '*') {
+                state = 'block';
+                i += 2;
+            }
+            else if (c === '@' && next === '"') {
+                state = 'verbatim';
+                i += 2;
+            }
+            else if ((c === '$' && next === '@') || (c === '@' && next === '$')) {
+                if (line[i + 2] === '"') {
+                    state = 'verbatim'; // interpolated verbatim ($@"…" / @$"…")
+                    i += 3;
+                }
+                else {
+                    i++;
+                }
+            }
+            else if (c === '"') {
+                let k = i;
+                while (k < n && line[k] === '"')
+                    k++;
+                const run = k - i;
+                if (run >= 3) {
+                    state = 'raw';
+                    rawFence = run;
+                    i = k;
+                }
+                else if (run === 2) {
+                    i = k; // "" — empty string
+                }
+                else {
+                    // single-line regular / interpolated string; consume to closer
+                    let j = i + 1;
+                    while (j < n) {
+                        if (line[j] === '\\') {
+                            j += 2;
+                            continue;
+                        }
+                        if (line[j] === '"')
+                            break;
+                        j++;
+                    }
+                    i = j >= n ? n : j + 1;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    return [state, rawFence];
+}
+/** Line-scanner used when no cached tree is available (worker-parsed files
+ *  can't transfer native tree-sitter Trees across MessageChannels, so
+ *  `treeCache` is empty for them). Re-parsing every C# file here with
+ *  tree-sitter was the dominant scope-resolution cost on large worker-mode
+ *  runs — for a multi-thousand-file solution this loop alone re-parsed the
+ *  whole repo a second time. The scanner extracts the same `namespaces` /
+ *  `usingStaticPaths` the AST walk produces for line-anchored declarations,
+ *  while tracking block-comment and string state across lines (via
+ *  `advanceCsScanState`) so a `namespace` / `using static` keyword at the
+ *  start of a line inside a block comment, verbatim string, or raw string
+ *  literal is NOT mistaken for a declaration. The remaining trade-off vs the
+ *  AST is a declaration whose keyword is not at the start of a code line
+ *  (split across lines, or sharing a line with a comment/string closer).
+ *  Mirrors PHP's `extractNamespaceViaScanner` (issue #1741). */
+export function extractCsharpStructureViaScanner(content) {
+    const namespaces = [];
+    const usingStaticPaths = [];
+    let state = 'code';
+    let rawFence = 0;
+    for (const line of content.split('\n')) {
+        // Only match when the line START is real code — keywords reached while
+        // inside a block comment / multi-line string are skipped.
+        if (state === 'code') {
+            const ns = CS_NAMESPACE_RE.exec(line);
+            if (ns !== null) {
+                namespaces.push(ns[1]);
+            }
+            else {
+                const us = CS_USING_STATIC_RE.exec(line);
+                if (us !== null)
+                    usingStaticPaths.push(us[1]);
+            }
+        }
+        [state, rawFence] = advanceCsScanState(line, state, rawFence);
+    }
+    return { namespaces, usingStaticPaths };
+}
+/** Build a structural view of a C# file. Prefers `cachedTree` (handed in
+ *  via `treeCache`) and walks the tree-sitter AST — the authoritative
+ *  path that sees `global using static`, aliased `using static X = Y.Z;`,
+ *  attributed namespace declarations, and preprocessor-guarded nodes
+ *  correctly. On cache miss (worker-parsed files, whose native Trees
+ *  can't cross MessageChannels) it falls back to the line scanner instead
+ *  of a fresh tree-sitter parse — the parse here dominated worker-mode
+ *  scope-resolution time. Parser singleton is shared across calls. */
 function extractFileStructure(content, cachedTree) {
-    const tree = cachedTree ??
-        parseSourceSafe(getCsharpParser(), content, undefined, {
-            bufferSize: getTreeSitterBufferSize(content),
-        });
+    if (!cachedTree) {
+        return extractCsharpStructureViaScanner(content);
+    }
+    const tree = cachedTree;
     const namespaces = [];
     const usingStaticPaths = [];
     const visit = (node) => {
@@ -238,6 +405,9 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
     // scope, so `Record(...)` (without `Logger.` qualifier) resolves
     // to `Logger.Record`. AST walk above captured these (including
     // `global using static` and aliased forms).
+    // Pre-index files by path once: the member-injection lookup below would
+    // otherwise be an O(files) scan per `using static` import.
+    const fileByPath = new Map(parsedFiles.map((p) => [p.filePath, p]));
     for (const parsed of parsedFiles) {
         const struct = structureByFile.get(parsed.filePath);
         if (struct === undefined)
@@ -245,6 +415,9 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
+        // Per-file de-dup sets keyed by simple name, seeded lazily from the
+        // augmentation bucket — replaces the per-member O(A) `.some` scan below.
+        const seenByName = new Map();
         for (const fullPath of struct.usingStaticPaths) {
             const lastDot = fullPath.lastIndexOf('.');
             if (lastDot === -1)
@@ -265,7 +438,7 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             // Inject the class's member methods into the importer's module
             // scope. `memberByOwner` wasn't built yet here, so we walk the
             // file's localDefs to find members with `ownerId === targetDef.nodeId`.
-            const targetFile = parsedFiles.find((p) => p.filePath === targetDef.filePath);
+            const targetFile = fileByPath.get(targetDef.filePath);
             if (targetFile === undefined)
                 continue;
             for (const memberDef of targetFile.localDefs) {
@@ -282,8 +455,16 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 // `lookupBindingsAt`, which fans out across `bindings` +
                 // `bindingAugmentations`.
                 const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
-                if (bucketArr.some((b) => b.def.nodeId === memberDef.nodeId))
+                let seen = seenByName.get(simpleName);
+                if (seen === undefined) {
+                    seen = new Set();
+                    for (const b of bucketArr)
+                        seen.add(b.def.nodeId);
+                    seenByName.set(simpleName, seen);
+                }
+                if (seen.has(memberDef.nodeId))
                     continue;
+                seen.add(memberDef.nodeId);
                 bucketArr.push({ def: memberDef, origin: 'import' });
             }
         }
@@ -299,6 +480,9 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
+        // Per-file de-dup sets keyed by simple name, seeded lazily from the
+        // augmentation bucket — replaces the per-def O(A) `.some` scan below.
+        const seenByName = new Map();
         for (const imp of parsed.parsedImports) {
             if (imp.kind !== 'namespace')
                 continue;
@@ -316,16 +500,35 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 if (simpleName === '')
                     continue;
                 const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
-                if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
+                let seen = seenByName.get(simpleName);
+                if (seen === undefined) {
+                    seen = new Set();
+                    for (const b of bucketArr)
+                        seen.add(b.def.nodeId);
+                    seenByName.set(simpleName, seen);
+                }
+                if (seen.has(def.nodeId))
                     continue;
+                seen.add(def.nodeId);
                 bucketArr.push({ def, origin: 'namespace' });
             }
         }
     }
-    for (const [, bucket] of buckets) {
-        // De-dup by (nodeId, filePath) across multiple declarations (e.g.
-        // partial classes declaring the same name in two files — we take
-        // both and leave de-dup to downstream consumers of bindings).
+    // Workspace-level binding channel for global-namespace types (see the
+    // global fast-path below). `lookupBindingsAt` consults this as a third
+    // source after finalized + per-scope augmented bindings. Its inner arrays
+    // are mutable by contract (append-only, like `bindingAugmentations` — see
+    // the ScopeResolutionIndexes doc + validateBindingsImmutability), so the
+    // ReadonlyMap→Map cast is localized to this one line and all writes go
+    // through `getWorkspaceBucket`.
+    const workspace = indexes.workspaceFqnBindings;
+    for (const [nsName, bucket] of buckets) {
+        // Group sibling defs by simple name. Append in place — the previous
+        // `[...prev, def]` copy made this O(D²) per bucket, which on the
+        // global (`''`) namespace bucket of a large Unity solution (tens of
+        // thousands of type defs) was a primary slowness/OOM source. We keep
+        // every declaration (e.g. partial classes across files) and leave
+        // de-dup to downstream consumers.
         const defsByName = new Map();
         for (const def of bucket.classDefs) {
             // Simple name = last segment of qualifiedName (e.g. `App.User` → `User`).
@@ -333,27 +536,81 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             const key = q.includes('.') ? q.slice(q.lastIndexOf('.') + 1) : q;
             if (key === '')
                 continue;
-            const arr = [...(defsByName.get(key) ?? [])];
+            let arr = defsByName.get(key);
+            if (arr === undefined) {
+                arr = [];
+                defsByName.set(key, arr);
+            }
             arr.push(def);
-            defsByName.set(key, arr);
+        }
+        // Global-namespace fast path (Unity OOM guard). Types declared in the
+        // default (global) namespace are visible from EVERY file in C# — the
+        // global namespace is always implicitly in scope — so one workspace-
+        // level entry per simple name is both semantically correct and O(D)
+        // instead of the O(S·D) per-scope augmentation that materialized
+        // billions of BindingRefs on large Unity solutions (tens of thousands
+        // of global types × tens of thousands of scopes). `walkScopeChain`
+        // checks local `scope.bindings` first, so local declarations still
+        // shadow these workspace entries; a file resolving its own global type
+        // hits the local binding before this map. Dedup by `def.nodeId` keeps
+        // partial-class / duplicate declarations from double-emitting.
+        if (nsName === '') {
+            for (const [name, defs] of defsByName) {
+                const bucket = getWorkspaceBucket(workspace, name);
+                const seen = new Set();
+                for (const b of bucket)
+                    seen.add(b.def.nodeId);
+                for (const def of defs) {
+                    if (seen.has(def.nodeId))
+                        continue; // dedup by nodeId (keeps partials, drops re-emits)
+                    seen.add(def.nodeId);
+                    bucket.push({ def, origin: 'namespace' });
+                }
+            }
+            continue;
+        }
+        // Pre-index the first scope per file once (O(S)) instead of an
+        // O(S) `.find` re-run for every (scope, name) pair, which made the
+        // injection loop O(S²·D) and was the dominant cost on large buckets.
+        // Multiple scopes share a filePath (Module + Namespace); the local
+        // shadow check only needs that file's lexical `Scope.bindings`, which
+        // is identical regardless of which of those scopes we read.
+        const firstScopeByFile = new Map();
+        for (const s of bucket.scopes) {
+            if (!firstScopeByFile.has(s.filePath))
+                firstScopeByFile.set(s.filePath, s.scope);
         }
         for (const { scopeId, filePath } of bucket.scopes) {
+            const localScope = firstScopeByFile.get(filePath);
             for (const [name, defs] of defsByName) {
                 // Skip names already present locally — `origin: 'local'` in
                 // scope.bindings would naturally shadow the cross-file
                 // namespace entry, but we also keep this index lean.
-                const local = bucket.scopes.find((s) => s.filePath === filePath)?.scope.bindings.get(name);
+                const local = localScope?.bindings.get(name);
                 if (local !== undefined && local.some((b) => b.origin === 'local'))
                     continue;
-                let bucketArr = null;
+                // Bind the augmentation bucket and its seeded de-dup set together
+                // under one nullable lifecycle, so neither needs a non-null
+                // assertion (they are always set or unset as a pair). Stays lazy:
+                // nothing is allocated for a name with no cross-file defs.
+                let inject = null;
                 for (const def of defs) {
                     if (def.filePath === filePath)
                         continue; // don't self-reference
-                    if (bucketArr === null)
-                        bucketArr = getAugmentationBucket(augmentations, scopeId, name);
-                    if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
+                    if (inject === null) {
+                        const bucket = getAugmentationBucket(augmentations, scopeId, name);
+                        // Seed the de-dup set from any entries an earlier pass
+                        // (using-static / cross-namespace imports) already added,
+                        // replacing the per-def O(A) `.some` scan.
+                        const seen = new Set();
+                        for (const b of bucket)
+                            seen.add(b.def.nodeId);
+                        inject = { bucket, seen };
+                    }
+                    if (inject.seen.has(def.nodeId))
                         continue;
-                    bucketArr.push({ def, origin: 'namespace' });
+                    inject.seen.add(def.nodeId);
+                    inject.bucket.push({ def, origin: 'namespace' });
                 }
             }
         }
@@ -378,6 +635,21 @@ function getAugmentationBucket(augmentations, scopeId, name) {
     }
     return bucketArr;
 }
+/** Get-or-create a mutable inner bucket inside the `workspaceFqnBindings`
+ *  channel (the scope-independent third channel; see
+ *  `ScopeResolutionIndexes.workspaceFqnBindings`). Like
+ *  `getAugmentationBucket`, the inner arrays are mutable by contract —
+ *  callers `push` directly. Keeping the get-or-create here means the one
+ *  ReadonlyMap→Map cast at the call site is the only place the mutable
+ *  view is taken. */
+function getWorkspaceBucket(workspace, name) {
+    let bucketArr = workspace.get(name);
+    if (bucketArr === undefined) {
+        bucketArr = [];
+        workspace.set(name, bucketArr);
+    }
+    return bucketArr;
+}
 function isTypeDef(def) {
     return (def.type === 'Class' ||
         def.type === 'Interface' ||

package/dist/core/ingestion/method-extractors/configs/c-cpp.js

@@ -2,6 +2,7 @@
 // Verified against tree-sitter-cpp ^0.23.4
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { hasKeyword } from '../../field-extractors/configs/helpers.js';
+import { classifyCppParameterType } from '../../languages/cpp/arity-metadata.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 // ---------------------------------------------------------------------------
 // C/C++ helpers
@@ -140,6 +141,7 @@ function extractCppParameters(node) {
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
                     rawType: typeNode?.text?.trim() ?? null,
+                    typeClass: classifyCppParameterType(typeNode?.text?.trim() ?? 'unknown', declNode?.text, param.text),
                     isOptional: false,
                     isVariadic: false,
                 });
@@ -155,6 +157,7 @@ function extractCppParameters(node) {
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
                     rawType: typeNode?.text?.trim() ?? null,
+                    typeClass: classifyCppParameterType(typeNode?.text?.trim() ?? 'unknown', declNode?.text, param.text),
                     isOptional: true,
                     isVariadic: false,
                 });
@@ -171,6 +174,7 @@ function extractCppParameters(node) {
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
                     rawType: typeNode?.text?.trim() ?? null,
+                    typeClass: classifyCppParameterType(typeNode?.text?.trim() ?? 'unknown', declNode?.text, param.text),
                     isOptional: false,
                     isVariadic: true,
                 });

package/dist/core/ingestion/method-types.d.ts

@@ -1,4 +1,4 @@
-import type { SupportedLanguages } from '../../_shared/index.js';
+import type { ParameterTypeClass, SupportedLanguages } from '../../_shared/index.js';
 import type { FieldVisibility } from './field-types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
 export type MethodVisibility = FieldVisibility;
@@ -9,6 +9,7 @@ export interface ParameterInfo {
      *  Used by typeTagForId for overload disambiguation where generic args matter.
      *  Falls back to `type` when not set. */
     rawType?: string | null;
+    typeClass?: ParameterTypeClass;
     isOptional: boolean;
     isVariadic: boolean;
 }

package/dist/core/ingestion/model/scope-resolution-indexes.d.ts

@@ -63,11 +63,15 @@ export interface ScopeResolutionIndexes {
      *  are returned first and win duplicate `def.nodeId` metadata, with
      *  unique augmentations appended after. See I8. */
     readonly bindingAugmentations: ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>;
-    /** Workspace-level FQN binding lookup. Populated by PHP namespace-
-     *  siblings Step 3b as a shared map instead of per-scope duplication.
-     *  Consulted by `lookupBindingsAt` as a third source after finalized
-     *  and per-scope augmented bindings. Keys are backslash-separated FQNs
-     *  (e.g. `App\Models\User`). */
+    /** Workspace-level binding lookup, shared instead of per-scope
+     *  duplication. Consulted by `lookupBindingsAt` as a third source after
+     *  finalized and per-scope augmented bindings. Language-specific
+     *  namespace-sibling hooks populate it with disjoint key formats that
+     *  never collide — e.g. backslash-separated FQNs (`App\Models\User`) for
+     *  backslash-namespace languages, and bare simple names (`User`) for
+     *  global-/default-namespace types that are visible from every file. The
+     *  shared map gives those workspace-wide names one entry each instead of
+     *  O(scopes × defs) per-scope augmentation. */
     readonly workspaceFqnBindings: ReadonlyMap<string, readonly BindingRef[]>;
     /** Pre-resolution usage facts; consumed by the resolution phase. */
     readonly referenceSites: readonly ReferenceSite[];

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

@@ -10,7 +10,7 @@ import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
-import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from './utils/method-props.js';
+import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, parameterShapeIdTag, } from './utils/method-props.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';
@@ -504,6 +504,9 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 arityTag += typeTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, language, cached.groups);
                 arityTag += constTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, cached.groups);
             }
+            const parameterShapeTag = nodeLabel === 'Function' || nodeLabel === 'Method'
+                ? parameterShapeIdTag(methodProps.parameterTypes, methodProps.parameterTypeClasses)
+                : '';
             const classTemplateArguments = extractedClassSymbol?.templateArguments ??
                 provider.classExtractor?.extractTemplateArgumentsFromCapture?.({
                     captureMap,
@@ -551,7 +554,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                     constraintsTag = '';
                 }
             }
-            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${constraintsTag}`);
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${constraintsTag}${parameterShapeTag}`);
             const classNodeForSymbol = definitionNodeForRange || definitionNode || nameNode;
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)

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

@@ -16,7 +16,7 @@
  * a different file-level fallback — cross that bridge when they
  * migrate.
  */
-import type { NodeLabel, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
+import type { NodeLabel, ParameterTypeClass, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import { type GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 /**
@@ -40,6 +40,7 @@ export declare function resolveDefGraphId(filePath: string, def: {
     qualifiedName?: string;
     type?: NodeLabel;
     parameterTypes?: readonly string[];
+    parameterTypeClasses?: readonly ParameterTypeClass[];
     templateArguments?: readonly string[];
     templateConstraints?: unknown;
 }, nodeLookup: GraphNodeLookup): string | undefined;

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

@@ -19,6 +19,7 @@
 import { generateId } from '../../../../lib/utils.js';
 import { qualifiedKey, simpleKey } from '../graph-bridge/node-lookup.js';
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
+import { parameterShapeIdTag } from '../../utils/method-props.js';
 /**
  * Labels that may legitimately ANCHOR a CALLS/ACCESSES edge as the
  * source ("caller"). A Variable / Property can be the TARGET of an
@@ -82,10 +83,21 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
             if (cHit !== undefined)
                 return cHit;
         }
+        if ((def.type === 'Function' || def.type === 'Method') &&
+            def.parameterTypes !== undefined &&
+            def.parameterTypeClasses !== undefined) {
+            const shapeTag = parameterShapeIdTag(def.parameterTypes, def.parameterTypeClasses);
+            if (shapeTag !== '') {
+                const shapeKey = qualifiedKey(filePath, def.type, `${qn}${shapeTag}`);
+                const shapeHit = nodeLookup.get(shapeKey);
+                if (shapeHit !== undefined)
+                    return shapeHit;
+            }
+        }
         // 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.
-        if (def.type === 'Method' &&
+        if ((def.type === 'Function' || def.type === 'Method') &&
             def.parameterTypes !== undefined &&
             def.parameterTypes.length > 0) {
             const pKey = qualifiedKey(filePath, def.type, `${qn}~${def.parameterTypes.join(',')}`);

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

@@ -18,6 +18,7 @@
  * format that downstream consumers (queries, edges, MCP) expect.
  */
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
+import { parameterShapeIdTag } from '../../utils/method-props.js';
 /**
  * Parse a qualified name out of a Function/Method node id.
  *
@@ -37,6 +38,9 @@ function parseQualifiedFromId(id, label, filePath) {
     const hash = suffix.indexOf('#');
     return hash === -1 ? suffix : suffix.slice(0, hash);
 }
+function stripCallableDisambiguatorTags(qualifiedName) {
+    return qualifiedName.replace(/~shape:.*$/, '').replace(/~c:[a-z0-9]+$/, '');
+}
 /**
  * Build a qualified-key string in a separate keyspace from simple-key
  * strings. Prefix `<q>` can't appear in a valid filePath on any OS, so
@@ -72,7 +76,8 @@ export function buildGraphNodeLookup(graph) {
         // `def save` vs `class User: def save`).
         const qualified = props.qualifiedName ?? parseQualifiedFromId(node.id, node.label, props.filePath);
         if (qualified !== undefined && qualified.length > 0) {
-            const qKey = qualifiedKey(props.filePath, node.label, qualified);
+            const keyQualified = stripCallableDisambiguatorTags(qualified);
+            const qKey = qualifiedKey(props.filePath, node.label, keyQualified);
             if (!lookup.has(qKey))
                 lookup.set(qKey, node.id);
             // Overload-disambiguating key: include parameter types so two
@@ -82,10 +87,21 @@ export function buildGraphNodeLookup(graph) {
             // a parameter-types-suffixed key so resolveDefGraphId can find
             // the right overload by matching its def's parameterTypes.
             const pTypes = props.parameterTypes;
-            if (pTypes !== undefined && pTypes.length > 0 && node.label === 'Method') {
-                const pKey = qualifiedKey(props.filePath, node.label, `${qualified}~${pTypes.join(',')}`);
+            if (pTypes !== undefined &&
+                pTypes.length > 0 &&
+                (node.label === 'Function' || node.label === 'Method')) {
+                const pKey = qualifiedKey(props.filePath, node.label, `${keyQualified}~${pTypes.join(',')}`);
                 // Each overload is unique — set unconditionally.
-                lookup.set(pKey, node.id);
+                if (!lookup.has(pKey))
+                    lookup.set(pKey, node.id);
+            }
+            const pClasses = props
+                .parameterTypeClasses;
+            const shapeTag = parameterShapeIdTag(pTypes, pClasses);
+            if (shapeTag !== '' && (node.label === 'Function' || node.label === 'Method')) {
+                const shapeKey = qualifiedKey(props.filePath, node.label, `${keyQualified}${shapeTag}`);
+                if (!lookup.has(shapeKey))
+                    lookup.set(shapeKey, node.id);
             }
             // SFINAE / `requires`-clause disambiguation (issue #1579) — register
             // a constraint-fingerprinted key so resolveDefGraphId can locate the
@@ -95,7 +111,7 @@ export function buildGraphNodeLookup(graph) {
             // `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)}`);
+                const cKey = qualifiedKey(props.filePath, node.label, `${keyQualified}${templateConstraintsIdTag(tConstraints)}`);
                 lookup.set(cKey, node.id);
             }
             if ((node.label === 'Class' ||
@@ -105,7 +121,7 @@ export function buildGraphNodeLookup(graph) {
                 node.label === 'Record') &&
                 props.templateArguments !== undefined &&
                 props.templateArguments.length > 0) {
-                const tKey = qualifiedKey(props.filePath, node.label, `${qualified}~${props.templateArguments.join(',')}`);
+                const tKey = qualifiedKey(props.filePath, node.label, `${keyQualified}~${props.templateArguments.join(',')}`);
                 if (!lookup.has(tKey))
                     lookup.set(tKey, node.id);
             }

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

@@ -35,6 +35,11 @@
  *       candidates whose template constraints provably fail at the
  *       call site. Three-valued; `'unknown'` keeps the candidate
  *       (monotonicity).
+ *   4d. Conservative C++ template partial-order approximation. When
+ *       template-placeholder overloads remain tied, prefer a candidate
+ *       whose parameter shape is more specialized for the observed
+ *       argument shape (`T*` over `T`, `const T&` over `T`). Unknown or
+ *       incomparable shapes are left ambiguous.
  *   5. Empty input returns empty output.
  */
 import type { ArityVerdict, Callsite, ConstraintContext, ParameterTypeClass, SymbolDefinition } from '../../../../_shared/index.js';

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

@@ -35,6 +35,11 @@
  *       candidates whose template constraints provably fail at the
  *       call site. Three-valued; `'unknown'` keeps the candidate
  *       (monotonicity).
+ *   4d. Conservative C++ template partial-order approximation. When
+ *       template-placeholder overloads remain tied, prefer a candidate
+ *       whose parameter shape is more specialized for the observed
+ *       argument shape (`T*` over `T`, `const T&` over `T`). Unknown or
+ *       incomparable shapes are left ambiguous.
  *   5. Empty input returns empty output.
  */
 export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx) {
@@ -133,6 +138,11 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
             return hookCtx.constraintCompatibility(callsite, def, ctx) !== 'incompatible';
         });
     }
+    if (result.length > 1 && argTypes !== undefined && argTypes.length > 0) {
+        const partiallyOrdered = rankByTemplatePartialOrdering(result, argTypes, hookCtx?.argumentTypeClasses);
+        if (partiallyOrdered !== undefined)
+            result = partiallyOrdered;
+    }
     return result;
 }
 function exactTypeSlotMatches(argType, paramType, argTypeClass, paramTypeClass) {
@@ -248,6 +258,110 @@ function pairwiseCompare(a, b) {
         return 1;
     return 0;
 }
+/**
+ * Closed-table approximation of C++ function-template partial ordering.
+ *
+ * Full `[temp.func.order]` requires template argument deduction. GitNexus
+ * keeps this graph-safe by recognizing only syntactic placeholder shapes
+ * that the C++ parameter sidecar already preserves:
+ *   - `T*` is more specialized than `T` for pointer arguments.
+ *
+ * Anything with unknown argument shape, non-template parameter spelling, or
+ * incomparable specialized shapes stays ambiguous so callers suppress. The
+ * placeholder detector is intentionally narrow: lowercase template parameters
+ * are left ambiguous rather than guessed.
+ */
+function rankByTemplatePartialOrdering(candidates, argTypes, argTypeClasses) {
+    if (argTypeClasses === undefined)
+        return undefined;
+    const viable = [];
+    for (const def of candidates) {
+        const params = def.parameterTypes;
+        const paramClasses = def.parameterTypeClasses;
+        if (params === undefined || paramClasses === undefined)
+            continue;
+        const ranks = [];
+        let sawTemplateSlot = false;
+        let ok = true;
+        for (let i = 0; i < argTypes.length; i++) {
+            const paramType = parameterTypeAt(params, i);
+            const paramClass = parameterTypeClassAt(paramClasses, i);
+            const argClass = argTypeClasses[i];
+            if (paramType === undefined || paramClass === undefined || argClass === undefined) {
+                ok = false;
+                break;
+            }
+            const rank = templatePartialOrderSlotRank(paramType, paramClass, argClass);
+            if (rank === undefined) {
+                ok = false;
+                break;
+            }
+            sawTemplateSlot ||= isTemplatePlaceholder(paramType);
+            ranks.push(rank);
+        }
+        if (ok && sawTemplateSlot)
+            viable.push({ def, ranks });
+    }
+    if (viable.length === 0)
+        return undefined;
+    if (viable.length !== candidates.length)
+        return [];
+    if (viable.length <= 1)
+        return viable.map((v) => v.def);
+    const dominated = new Set();
+    for (let i = 0; i < viable.length; i++) {
+        if (dominated.has(i))
+            continue;
+        for (let j = i + 1; j < viable.length; j++) {
+            if (dominated.has(j))
+                continue;
+            const cmp = compareSpecializationRanks(viable[i].ranks, viable[j].ranks);
+            if (cmp < 0)
+                dominated.add(j);
+            else if (cmp > 0)
+                dominated.add(i);
+        }
+    }
+    return viable.filter((_, idx) => !dominated.has(idx)).map((v) => v.def);
+}
+function templatePartialOrderSlotRank(paramType, paramClass, argClass) {
+    if (!isTemplatePlaceholder(paramType))
+        return undefined;
+    if (argClass.indirection === 'unknown' || paramClass.indirection === 'unknown') {
+        return undefined;
+    }
+    if (isPointerShape(paramClass)) {
+        return isPointerShape(argClass) ? 3 : undefined;
+    }
+    if (paramClass.indirection === 'value')
+        return 1;
+    return undefined;
+}
+function isTemplatePlaceholder(typeName) {
+    return /^[A-Z]\w*$/.test(typeName);
+}
+/**
+ * Higher specialization rank is better. Returns -1 when `a` dominates `b`,
+ * +1 when `b` dominates `a`, and 0 for ties / incomparable vectors.
+ */
+function compareSpecializationRanks(a, b) {
+    let aBetter = false;
+    let bBetter = false;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        if (a[i] > b[i])
+            aBetter = true;
+        else if (b[i] > a[i])
+            bBetter = true;
+        if (aBetter && bBetter)
+            return 0;
+    }
+    if (aBetter && !bBetter)
+        return -1;
+    if (bBetter && !aBetter)
+        return 1;
+    return 0;
+}
 /**
  * Detect when >1 candidate share identical `parameterTypes` after the
  * per-language normalizer has collapsed distinct underlying types. This

package/dist/core/ingestion/scope-resolution/pipeline/validate-bindings-immutability.d.ts

@@ -1,6 +1,6 @@
 /**
- * Dev-mode runtime validator for the two-channel binding lifecycle
- * (Contract Invariant I8 in `contract/scope-resolver.ts`).
+ * Dev-mode runtime validator for the post-finalize binding-channel
+ * lifecycle (Contract Invariant I8 in `contract/scope-resolver.ts`).
  *
  * The two channels:
  *   - `indexes.bindings` — finalize-output channel. After

package/dist/core/ingestion/scope-resolution/pipeline/validate-bindings-immutability.js

@@ -1,6 +1,6 @@
 /**
- * Dev-mode runtime validator for the two-channel binding lifecycle
- * (Contract Invariant I8 in `contract/scope-resolver.ts`).
+ * Dev-mode runtime validator for the post-finalize binding-channel
+ * lifecycle (Contract Invariant I8 in `contract/scope-resolver.ts`).
  *
  * The two channels:
  *   - `indexes.bindings` — finalize-output channel. After
@@ -61,5 +61,18 @@ export function validateBindingsImmutability(indexes, onWarn) {
             }
         }
     }
+    // Third channel: `workspaceFqnBindings` (scope-independent, shared map
+    // populated by language namespace-sibling hooks — PHP FQN keys, C#
+    // global-namespace simple names). Like bindingAugmentations its inner
+    // arrays are mutable by contract (hooks `push()` directly), so freezing
+    // one is the same defect as freezing an augmentation bucket.
+    for (const [name, bucket] of indexes.workspaceFqnBindings) {
+        if (Object.isFrozen(bucket)) {
+            onWarn(`binding-immutability: indexes.workspaceFqnBindings[${name}] is FROZEN — ` +
+                `the workspace channel is mutable by contract; freezing it defeats the ` +
+                `append-only purpose. See ScopeResolver Invariant I8.`);
+            violations++;
+        }
+    }
     return violations;
 }

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

@@ -55,6 +55,14 @@ export declare function lookupBindingsAt(scopeId: ScopeId, name: string, scopes:
  * Fast paths (zero allocation) when at most one channel is populated:
  * returns the underlying `Map.keys()` iterator directly. Only when both
  * channels carry names do we materialize a `Set` for deduplication.
+ *
+ * Scope: enumerates only the per-scope `bindings` and `bindingAugmentations`
+ * channels. It deliberately EXCLUDES the scope-independent
+ * `workspaceFqnBindings` channel (PHP FQN keys, C# global-namespace simple
+ * names). `lookupBindingsAt` consults that third channel when resolving a
+ * specific name, but name *enumeration* here does not — those names apply at
+ * every scope and would flood per-scope callers. Callers that need
+ * workspace-level names must read `workspaceFqnBindings` directly.
  */
 export declare function namesAtScope(scopeId: ScopeId, scopes: ScopeResolutionIndexes): Iterable<string>;
 /**

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

@@ -92,6 +92,14 @@ const EMPTY_NAMES = Object.freeze([]);
  * Fast paths (zero allocation) when at most one channel is populated:
  * returns the underlying `Map.keys()` iterator directly. Only when both
  * channels carry names do we materialize a `Set` for deduplication.
+ *
+ * Scope: enumerates only the per-scope `bindings` and `bindingAugmentations`
+ * channels. It deliberately EXCLUDES the scope-independent
+ * `workspaceFqnBindings` channel (PHP FQN keys, C# global-namespace simple
+ * names). `lookupBindingsAt` consults that third channel when resolving a
+ * specific name, but name *enumeration* here does not — those names apply at
+ * every scope and would flood per-scope callers. Callers that need
+ * workspace-level names must read `workspaceFqnBindings` directly.
  */
 export function namesAtScope(scopeId, scopes) {
     const finalized = scopes.bindings.get(scopeId);

package/dist/core/ingestion/utils/method-props.d.ts

@@ -1,5 +1,5 @@
 import type { MethodInfo } from '../method-types.js';
-import { SupportedLanguages } from '../../../_shared/index.js';
+import { SupportedLanguages, type ParameterTypeClass } from '../../../_shared/index.js';
 /**
  * Compute arity for ID-generation purposes.
  * Returns `undefined` when any parameter is variadic (arity is indeterminate).
@@ -28,5 +28,15 @@ collisionGroups?: Map<string, MethodInfo[]>): string;
 export declare function constTagForId(methodMap: Map<string, MethodInfo>, methodName: string, arity: number | undefined, currentInfo: MethodInfo, 
 /** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
 collisionGroups?: Map<string, MethodInfo[]>): string;
+/**
+ * Disambiguate function-template overloads whose normalized parameter types
+ * intentionally collapse to the same placeholder token (`T`, `U`, ...), but
+ * whose C++ sidecar shape is semantically different (`T` vs `T*` / `T&`).
+ *
+ * Kept intentionally narrow: concrete types already use the existing raw-type
+ * overload tag, and non-template languages should not acquire sidecar-shaped
+ * IDs.
+ */
+export declare function parameterShapeIdTag(parameterTypes?: readonly string[], parameterTypeClasses?: readonly ParameterTypeClass[]): string;
 /** Convert MethodInfo from methodExtractor into flat properties for a graph node. */
 export declare function buildMethodProps(info: MethodInfo): Record<string, unknown>;

package/dist/core/ingestion/utils/method-props.js

@@ -113,14 +113,53 @@ collisionGroups) {
     }
     return '';
 }
+/**
+ * Disambiguate function-template overloads whose normalized parameter types
+ * intentionally collapse to the same placeholder token (`T`, `U`, ...), but
+ * whose C++ sidecar shape is semantically different (`T` vs `T*` / `T&`).
+ *
+ * Kept intentionally narrow: concrete types already use the existing raw-type
+ * overload tag, and non-template languages should not acquire sidecar-shaped
+ * IDs.
+ */
+export function parameterShapeIdTag(parameterTypes, parameterTypeClasses) {
+    if (parameterTypes === undefined ||
+        parameterTypeClasses === undefined ||
+        parameterTypes.length === 0) {
+        return '';
+    }
+    let hasTemplatePlaceholder = false;
+    let hasDisambiguatingShape = false;
+    const parts = [];
+    for (let i = 0; i < parameterTypes.length; i++) {
+        const type = parameterTypes[i];
+        const typeClass = parameterTypeClasses[i];
+        if (typeClass === undefined)
+            return '';
+        if (/^[A-Z]\w*$/.test(type))
+            hasTemplatePlaceholder = true;
+        if (typeClass.indirection !== 'value' ||
+            typeClass.pointerDepth > 0 ||
+            (typeClass.cv !== 'none' && typeClass.cv !== 'unknown')) {
+            hasDisambiguatingShape = true;
+        }
+        parts.push(`${type}:${typeClass.cv}:${typeClass.indirection}:${typeClass.pointerDepth.toString()}`);
+    }
+    if (!hasTemplatePlaceholder || !hasDisambiguatingShape)
+        return '';
+    return `~shape:${parts.join('|')}`;
+}
 /** Convert MethodInfo from methodExtractor into flat properties for a graph node. */
 export function buildMethodProps(info) {
     const types = [];
+    const typeClasses = [];
     let optionalCount = 0;
     let hasVariadic = false;
     for (const p of info.parameters) {
         if (p.type !== null)
             types.push(p.type);
+        if (p.typeClass !== undefined)
+            typeClasses.push(p.typeClass);
         if (p.isOptional)
             optionalCount++;
         if (p.isVariadic)
@@ -132,6 +171,9 @@ export function buildMethodProps(info) {
             ? { requiredParameterCount: info.parameters.length - optionalCount }
             : {}),
         ...(types.length > 0 ? { parameterTypes: types } : {}),
+        ...(typeClasses.length === info.parameters.length && typeClasses.length > 0
+            ? { parameterTypeClasses: typeClasses }
+            : {}),
         returnType: info.returnType ?? undefined,
         visibility: info.visibility,
         isStatic: info.isStatic,

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

@@ -44,7 +44,7 @@ import { detectFrameworkFromAST } from '../framework-detection.js';
 import { generateId } from '../../../lib/utils.js';
 import { preprocessImportPath } from '../import-processor.js';
 import { extractVueScript, extractTemplateComponents, isVueSetupTopLevel, } from '../vue-sfc-extractor.js';
-import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from '../utils/method-props.js';
+import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, parameterShapeIdTag, } from '../utils/method-props.js';
 import { extractTemplateArguments, templateArgumentsIdTag } from '../utils/template-arguments.js';
 import { extractParsedFile } from '../scope-extractor-bridge.js';
 import { extractLaravelRoutes } from '../route-extractors/laravel.js';
@@ -1357,6 +1357,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 arityTag += typeTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, language, groups);
                 arityTag += constTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, groups);
             }
+            const parameterShapeTag = nodeLabel === 'Function' || nodeLabel === 'Method'
+                ? parameterShapeIdTag(methodProps.parameterTypes, methodProps.parameterTypeClasses)
+                : '';
             const classTemplateArguments = extractedClassSymbol?.templateArguments ??
                 provider.classExtractor?.extractTemplateArgumentsFromCapture?.({
                     captureMap,
@@ -1376,7 +1379,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 classTemplateArguments.length > 0
                 ? templateArgumentsIdTag(classTemplateArguments)
                 : '';
-            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}`);
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${parameterShapeTag}`);
             const classNodeForSymbol = definitionNode || nameNode;
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.90",
+  "version": "1.6.6-rc.92",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",