gitnexus 1.5.3 → 1.6.1

package/dist/core/ingestion/utils/env.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Environment constants shared across the ingestion module.
+ *
+ * Centralizes `isDev` so every file in `ingestion/` imports from
+ * one canonical location rather than re-declaring the check.
+ *
+ * @module
+ */
+/** Whether we're running in development mode (enables verbose console logging). */
+export declare const isDev: boolean;

package/dist/core/ingestion/utils/env.js

@@ -0,0 +1,10 @@
+/**
+ * Environment constants shared across the ingestion module.
+ *
+ * Centralizes `isDev` so every file in `ingestion/` imports from
+ * one canonical location rather than re-declaring the check.
+ *
+ * @module
+ */
+/** Whether we're running in development mode (enables verbose console logging). */
+export const isDev = process.env.NODE_ENV === 'development';

package/dist/core/ingestion/utils/graph-sort.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Topological level sort for file-level import graphs.
+ *
+ * Groups files into topological levels where files within the same level
+ * have no mutual import dependencies and can be processed in parallel.
+ * Files involved in import cycles are appended as a final group and
+ * processed last in an undefined order (best-effort propagation).
+ *
+ * Used by cross-file binding propagation to process files in the correct
+ * order — upstream exports must be resolved before downstream importers.
+ *
+ * @module
+ */
+/** A group of files with no mutual dependencies, safe to process in parallel. */
+export type IndependentFileGroup = readonly string[];
+/**
+ * Groups files by topological level using Kahn's algorithm on the **reverse**
+ * import graph.
+ *
+ * Files in the same level have no mutual dependencies — safe to process in parallel.
+ * Files involved in import cycles are appended as a final level and processed
+ * last in an undefined order (best-effort propagation, no ordering guarantees).
+ *
+ * ## Why the counter is named `pendingImportsPerFile` (not `inDegree`)
+ *
+ * Cross-file binding propagation must process **leaves first** — a file's
+ * imports must be resolved before the file itself is re-resolved. To get
+ * leaves first from Kahn's algorithm, we run Kahn's on the **reverse** of
+ * the import graph:
+ *
+ * - `importMap` is `importer → {imports}` (forward edges point at deps).
+ * - The reverse graph has edges `dep → {importers}`, materialized in
+ *   `reverseDeps`.
+ * - On the reverse graph, "in-degree of node X" equals "number of imports X
+ *   has in the forward graph" — i.e. X's forward **out-degree**.
+ *
+ * So `pendingImportsPerFile.get(file)` counts how many of `file`'s imports
+ * are still un-emitted. A file is ready (level 0 / appended to `currentLevel`)
+ * once all its imports have been emitted in earlier levels — that is, once
+ * its pending-imports count drops to 0. Pairing this counter with
+ * `reverseDeps` (dep → importers) is the standard Kahn's-on-the-reverse-graph
+ * formulation; it is **not** a bug to be "fixed" by counting forward
+ * in-degree (importers per file).
+ *
+ * **Do not rename this back to `inDegree` and do not invert the counting
+ * direction.** Doing either flips the emission order from leaves-first to
+ * roots-first, which silently breaks cross-file binding propagation
+ * (downstream files would be re-resolved before their upstream exports
+ * are available).
+ *
+ * @param importMap  Map of file → set of files it imports (forward graph)
+ * @returns          Levels (topologically ordered groups, leaves first)
+ *                   and count of files in cycles
+ */
+export declare function topologicalLevelSort(importMap: ReadonlyMap<string, ReadonlySet<string>>): {
+    levels: readonly IndependentFileGroup[];
+    cycleCount: number;
+};

package/dist/core/ingestion/utils/graph-sort.js

@@ -0,0 +1,100 @@
+/**
+ * Topological level sort for file-level import graphs.
+ *
+ * Groups files into topological levels where files within the same level
+ * have no mutual import dependencies and can be processed in parallel.
+ * Files involved in import cycles are appended as a final group and
+ * processed last in an undefined order (best-effort propagation).
+ *
+ * Used by cross-file binding propagation to process files in the correct
+ * order — upstream exports must be resolved before downstream importers.
+ *
+ * @module
+ */
+/**
+ * Groups files by topological level using Kahn's algorithm on the **reverse**
+ * import graph.
+ *
+ * Files in the same level have no mutual dependencies — safe to process in parallel.
+ * Files involved in import cycles are appended as a final level and processed
+ * last in an undefined order (best-effort propagation, no ordering guarantees).
+ *
+ * ## Why the counter is named `pendingImportsPerFile` (not `inDegree`)
+ *
+ * Cross-file binding propagation must process **leaves first** — a file's
+ * imports must be resolved before the file itself is re-resolved. To get
+ * leaves first from Kahn's algorithm, we run Kahn's on the **reverse** of
+ * the import graph:
+ *
+ * - `importMap` is `importer → {imports}` (forward edges point at deps).
+ * - The reverse graph has edges `dep → {importers}`, materialized in
+ *   `reverseDeps`.
+ * - On the reverse graph, "in-degree of node X" equals "number of imports X
+ *   has in the forward graph" — i.e. X's forward **out-degree**.
+ *
+ * So `pendingImportsPerFile.get(file)` counts how many of `file`'s imports
+ * are still un-emitted. A file is ready (level 0 / appended to `currentLevel`)
+ * once all its imports have been emitted in earlier levels — that is, once
+ * its pending-imports count drops to 0. Pairing this counter with
+ * `reverseDeps` (dep → importers) is the standard Kahn's-on-the-reverse-graph
+ * formulation; it is **not** a bug to be "fixed" by counting forward
+ * in-degree (importers per file).
+ *
+ * **Do not rename this back to `inDegree` and do not invert the counting
+ * direction.** Doing either flips the emission order from leaves-first to
+ * roots-first, which silently breaks cross-file binding propagation
+ * (downstream files would be re-resolved before their upstream exports
+ * are available).
+ *
+ * @param importMap  Map of file → set of files it imports (forward graph)
+ * @returns          Levels (topologically ordered groups, leaves first)
+ *                   and count of files in cycles
+ */
+export function topologicalLevelSort(importMap) {
+    // Per-file count of imports that have not yet been emitted in an earlier
+    // level. See JSDoc above for why this is **not** standard `inDegree`.
+    const pendingImportsPerFile = new Map();
+    const reverseDeps = new Map();
+    for (const [file, deps] of importMap) {
+        if (!pendingImportsPerFile.has(file))
+            pendingImportsPerFile.set(file, 0);
+        for (const dep of deps) {
+            if (!pendingImportsPerFile.has(dep))
+                pendingImportsPerFile.set(dep, 0);
+            pendingImportsPerFile.set(file, (pendingImportsPerFile.get(file) ?? 0) + 1);
+            let rev = reverseDeps.get(dep);
+            if (!rev) {
+                rev = [];
+                reverseDeps.set(dep, rev);
+            }
+            rev.push(file);
+        }
+    }
+    const levels = [];
+    // Level 0: files with no un-emitted imports (true leaves of the import graph).
+    let currentLevel = [...pendingImportsPerFile.entries()]
+        .filter(([, d]) => d === 0)
+        .map(([f]) => f);
+    while (currentLevel.length > 0) {
+        levels.push(currentLevel);
+        const nextLevel = [];
+        for (const file of currentLevel) {
+            // For each importer of `file`, one of its pending imports just got
+            // emitted — decrement the importer's pending count. If it hits 0,
+            // the importer is ready for the next level.
+            for (const dependent of reverseDeps.get(file) ?? []) {
+                const newPending = (pendingImportsPerFile.get(dependent) ?? 1) - 1;
+                pendingImportsPerFile.set(dependent, newPending);
+                if (newPending === 0)
+                    nextLevel.push(dependent);
+            }
+        }
+        currentLevel = nextLevel;
+    }
+    // Anything still > 0 participates in a cycle — append in undefined order.
+    const cycleFiles = [...pendingImportsPerFile.entries()].filter(([, d]) => d > 0).map(([f]) => f);
+    if (cycleFiles.length > 0) {
+        levels.push(cycleFiles);
+    }
+    return { levels, cycleCount: cycleFiles.length };
+}

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

@@ -0,0 +1,32 @@
+import type { MethodInfo } from '../method-types.js';
+import { SupportedLanguages } from '../../../_shared/index.js';
+/**
+ * Compute arity for ID-generation purposes.
+ * Returns `undefined` when any parameter is variadic (arity is indeterminate).
+ */
+export declare function arityForIdFromInfo(info: MethodInfo): number | undefined;
+/**
+ * Compute a type-based discriminator suffix for same-arity overloads.
+ * Returns `~type1,type2` when the current method collides with another method
+ * in the same class that has the same name and arity but different parameter types.
+ * Returns `''` when there is no collision or types are unavailable.
+ */
+/**
+ * Build collision groups from a method map — groups methods by `name#arity`.
+ * Call once per class, then pass to typeTagForId/constTagForId to avoid O(N²) scans.
+ */
+export declare function buildCollisionGroups(methodMap: Map<string, MethodInfo>): Map<string, MethodInfo[]>;
+export declare function typeTagForId(methodMap: Map<string, MethodInfo>, methodName: string, arity: number | undefined, currentInfo: MethodInfo, language?: SupportedLanguages, 
+/** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
+collisionGroups?: Map<string, MethodInfo[]>): string;
+/**
+ * Compute a const-qualifier suffix for C++ const/non-const method collisions.
+ * Returns `$const` when the current method is const-qualified and a non-const
+ * method with the same name and arity exists in the same class.
+ * Returns `''` when there is no collision or the method is not const-qualified.
+ */
+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;
+/** 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

@@ -0,0 +1,147 @@
+import { SupportedLanguages } from '../../../_shared/index.js';
+/** Languages where class overload signatures are declaration-only contracts
+ *  that should collapse to the implementation body's node ID. */
+const SKIP_TYPE_HASH_LANGUAGES = new Set([
+    SupportedLanguages.TypeScript,
+    SupportedLanguages.JavaScript,
+]);
+/**
+ * Compute arity for ID-generation purposes.
+ * Returns `undefined` when any parameter is variadic (arity is indeterminate).
+ */
+export function arityForIdFromInfo(info) {
+    return info.parameters.some((p) => p.isVariadic) ? undefined : info.parameters.length;
+}
+/**
+ * Compute a type-based discriminator suffix for same-arity overloads.
+ * Returns `~type1,type2` when the current method collides with another method
+ * in the same class that has the same name and arity but different parameter types.
+ * Returns `''` when there is no collision or types are unavailable.
+ */
+/**
+ * Build collision groups from a method map — groups methods by `name#arity`.
+ * Call once per class, then pass to typeTagForId/constTagForId to avoid O(N²) scans.
+ */
+export function buildCollisionGroups(methodMap) {
+    const groups = new Map();
+    for (const info of methodMap.values()) {
+        if (info.parameters.some((p) => p.isVariadic))
+            continue;
+        const key = `${info.name}#${info.parameters.length}`;
+        let group = groups.get(key);
+        if (!group) {
+            group = [];
+            groups.set(key, group);
+        }
+        group.push(info);
+    }
+    return groups;
+}
+export function typeTagForId(methodMap, methodName, arity, currentInfo, language, 
+/** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
+collisionGroups) {
+    if (arity === undefined)
+        return '';
+    // Zero-arity methods have no parameter types to disambiguate.
+    if (arity === 0)
+        return '';
+    // TS/JS class overload signatures are declaration-only contracts that should
+    // collapse to the implementation body's node ID, not be disambiguated.
+    if (language && SKIP_TYPE_HASH_LANGUAGES.has(language))
+        return '';
+    // Check if all parameters of this method have types (rawType or type)
+    if (currentInfo.parameters.length > 0 &&
+        currentInfo.parameters.some((p) => (p.rawType ?? p.type) === null)) {
+        return '';
+    }
+    // Use pre-built collision group if available, otherwise scan (backward compat)
+    const groupKey = `${methodName}#${arity}`;
+    const sameArityGroup = collisionGroups?.get(groupKey) ?? _buildGroup(methodMap, methodName, arity);
+    // No collision — single method with this name+arity
+    if (sameArityGroup.length < 2)
+        return '';
+    // Check that ALL methods in the collision group have full type info
+    for (const info of sameArityGroup) {
+        if (info.parameters.length > 0 && info.parameters.some((p) => (p.rawType ?? p.type) === null)) {
+            return '';
+        }
+    }
+    // Build type tag from current method's parameter types.
+    // Prefer rawType (preserves generic/template args like vector<int>) over
+    // type (simplified by extractSimpleTypeName which strips generics).
+    const types = currentInfo.parameters.map((p) => (p.rawType ?? p.type));
+    return `~${types.join(',')}`;
+}
+/** Fallback: build a same-arity group by scanning the full map (O(N)). */
+function _buildGroup(methodMap, methodName, arity) {
+    const group = [];
+    for (const info of methodMap.values()) {
+        if (info.name !== methodName)
+            continue;
+        if (info.parameters.some((p) => p.isVariadic))
+            continue;
+        if (info.parameters.length !== arity)
+            continue;
+        group.push(info);
+    }
+    return group;
+}
+/**
+ * Compute a const-qualifier suffix for C++ const/non-const method collisions.
+ * Returns `$const` when the current method is const-qualified and a non-const
+ * method with the same name and arity exists in the same class.
+ * Returns `''` when there is no collision or the method is not const-qualified.
+ */
+export function constTagForId(methodMap, methodName, arity, currentInfo, 
+/** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
+collisionGroups) {
+    if (!currentInfo.isConst)
+        return '';
+    if (arity === undefined)
+        return '';
+    // Use pre-built group if available
+    const groupKey = `${methodName}#${arity}`;
+    const group = collisionGroups?.get(groupKey);
+    const candidates = group ?? _buildGroup(methodMap, methodName, arity);
+    // Check if a non-const method exists in the collision group
+    for (const info of candidates) {
+        if (info === currentInfo)
+            continue;
+        if (info.isConst)
+            continue;
+        return '$const';
+    }
+    return '';
+}
+/** Convert MethodInfo from methodExtractor into flat properties for a graph node. */
+export function buildMethodProps(info) {
+    const types = [];
+    let optionalCount = 0;
+    let hasVariadic = false;
+    for (const p of info.parameters) {
+        if (p.type !== null)
+            types.push(p.type);
+        if (p.isOptional)
+            optionalCount++;
+        if (p.isVariadic)
+            hasVariadic = true;
+    }
+    return {
+        parameterCount: hasVariadic ? undefined : info.parameters.length,
+        ...(!hasVariadic && optionalCount > 0
+            ? { requiredParameterCount: info.parameters.length - optionalCount }
+            : {}),
+        ...(types.length > 0 ? { parameterTypes: types } : {}),
+        returnType: info.returnType ?? undefined,
+        visibility: info.visibility,
+        isStatic: info.isStatic,
+        isAbstract: info.isAbstract,
+        isFinal: info.isFinal,
+        ...(info.isVirtual ? { isVirtual: info.isVirtual } : {}),
+        ...(info.isOverride ? { isOverride: info.isOverride } : {}),
+        ...(info.isAsync ? { isAsync: info.isAsync } : {}),
+        ...(info.isPartial ? { isPartial: info.isPartial } : {}),
+        ...(info.isConst ? { isConst: info.isConst } : {}),
+        ...(info.annotations.length > 0 ? { annotations: info.annotations } : {}),
+    };
+}

package/dist/core/ingestion/vue-sfc-extractor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Vue SFC (Single File Component) script extractor.
+ *
+ * Extracts the <script> / <script setup> block content from .vue files
+ * so it can be parsed by the TypeScript tree-sitter grammar.
+ *
+ * Pure function — no tree-sitter dependency, safe for worker threads.
+ */
+export interface VueScriptExtraction {
+    /** Extracted script content (TypeScript/JavaScript) */
+    scriptContent: string;
+    /** 0-based line number in the .vue file where the script content starts */
+    lineOffset: number;
+    /** true if the primary block is <script setup> */
+    isSetup: boolean;
+}
+/**
+ * Extract script content from a Vue SFC.
+ *
+ * When both <script> and <script setup> are present, returns only the
+ * <script setup> block (the dominant pattern — 94% of Vue files in real
+ * projects use setup). The <script> (non-setup) block typically contains
+ * only `defineOptions` or legacy option merges and is less important for
+ * the knowledge graph.
+ */
+export declare function extractVueScript(vueContent: string): VueScriptExtraction | null;
+/**
+ * Vue <script setup>: all top-level bindings are implicitly exported.
+ * Returns true if the node (or any ancestor) has the `program` root as its
+ * direct parent — i.e. the node is at the top level of the script block.
+ *
+ * Shared between the worker and sequential parsing paths.
+ */
+export declare const isVueSetupTopLevel: (node: {
+    parent: {
+        type: string;
+        parent: unknown;
+    } | null;
+} | null) => boolean;
+/**
+ * Extract PascalCase component names used in <template>.
+ * Returns deduplicated component names (e.g., ["MyButton", "AppHeader"]).
+ */
+export declare function extractTemplateComponents(vueContent: string): string[];

package/dist/core/ingestion/vue-sfc-extractor.js

@@ -0,0 +1,94 @@
+/**
+ * Vue SFC (Single File Component) script extractor.
+ *
+ * Extracts the <script> / <script setup> block content from .vue files
+ * so it can be parsed by the TypeScript tree-sitter grammar.
+ *
+ * Pure function — no tree-sitter dependency, safe for worker threads.
+ */
+const SCRIPT_RE = /<script(\s[^>]*)?>([^]*?)<\/script>/g;
+const TEMPLATE_COMPONENT_RE = /<([A-Z][A-Za-z0-9]+)/g;
+// Greedy: matches from the first <template> to the *last* </template>.
+// This is intentional — nested <template v-slot:...> tags are valid Vue
+// syntax and we want the entire outermost template body.
+const TEMPLATE_RE = /<template(\s[^>]*)?>([^]*)<\/template>/;
+function countNewlines(text) {
+    let count = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            count++;
+    }
+    return count;
+}
+function parseScriptBlock(attrs, content, precedingText) {
+    const isSetup = attrs != null && /\bsetup\b/.test(attrs);
+    const langMatch = attrs?.match(/\blang\s*=\s*["']([^"']+)["']/);
+    const lang = langMatch ? langMatch[1] : '';
+    // +1 for the newline after the opening <script...> tag
+    const lineOffset = countNewlines(precedingText) + 1;
+    return { content, lineOffset, isSetup, lang };
+}
+/**
+ * Extract script content from a Vue SFC.
+ *
+ * When both <script> and <script setup> are present, returns only the
+ * <script setup> block (the dominant pattern — 94% of Vue files in real
+ * projects use setup). The <script> (non-setup) block typically contains
+ * only `defineOptions` or legacy option merges and is less important for
+ * the knowledge graph.
+ */
+export function extractVueScript(vueContent) {
+    const blocks = [];
+    let match;
+    // Reset lastIndex for reuse of the global regex
+    SCRIPT_RE.lastIndex = 0;
+    while ((match = SCRIPT_RE.exec(vueContent)) !== null) {
+        const precedingText = vueContent.slice(0, match.index + match[0].indexOf(match[2]));
+        blocks.push(parseScriptBlock(match[1], match[2], precedingText));
+    }
+    if (blocks.length === 0)
+        return null;
+    // Prefer <script setup> if present
+    const setupBlock = blocks.find((b) => b.isSetup);
+    const primary = setupBlock ?? blocks[0];
+    return {
+        scriptContent: primary.content,
+        lineOffset: primary.lineOffset,
+        isSetup: primary.isSetup,
+    };
+}
+/**
+ * Vue <script setup>: all top-level bindings are implicitly exported.
+ * Returns true if the node (or any ancestor) has the `program` root as its
+ * direct parent — i.e. the node is at the top level of the script block.
+ *
+ * Shared between the worker and sequential parsing paths.
+ */
+export const isVueSetupTopLevel = (node) => {
+    if (!node)
+        return false;
+    let current = node;
+    while (current) {
+        if (current.parent?.type === 'program')
+            return true;
+        current = current.parent;
+    }
+    return false;
+};
+/**
+ * Extract PascalCase component names used in <template>.
+ * Returns deduplicated component names (e.g., ["MyButton", "AppHeader"]).
+ */
+export function extractTemplateComponents(vueContent) {
+    const templateMatch = TEMPLATE_RE.exec(vueContent);
+    if (!templateMatch)
+        return [];
+    const templateContent = templateMatch[2];
+    const components = new Set();
+    let componentMatch;
+    TEMPLATE_COMPONENT_RE.lastIndex = 0;
+    while ((componentMatch = TEMPLATE_COMPONENT_RE.exec(templateContent)) !== null) {
+        components.add(componentMatch[1]);
+    }
+    return [...components];
+}

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

@@ -1,4 +1,5 @@
 import { SupportedLanguages } from '../../../_shared/index.js';
+import type { ExtractedHeritage } from '../model/heritage-map.js';
 import { type MixedChainStep } from '../utils/call-analysis.js';
 import type { ConstructorBinding } from '../type-env.js';
 import type { NamedBinding } from '../named-bindings/types.js';
@@ -16,13 +17,7 @@ interface ParsedNode {
         astFrameworkMultiplier?: number;
         astFrameworkReason?: string;
         description?: string;
-        parameterCount?: number;
-        requiredParameterCount?: number;
-        returnType?: string;
-        declaredType?: string;
-        visibility?: string;
-        isStatic?: boolean;
-        isReadonly?: boolean;
+        [key: string]: unknown;
     };
 }
 interface ParsedRelationship {
@@ -38,6 +33,7 @@ interface ParsedSymbol {
     name: string;
     nodeId: string;
     type: NodeLabel;
+    qualifiedName?: string;
     parameterCount?: number;
     requiredParameterCount?: number;
     parameterTypes?: string[];
@@ -93,13 +89,6 @@ export interface ExtractedAssignment {
     /** Resolved type name of the receiver if available from TypeEnv */
     receiverTypeName?: string;
 }
-export interface ExtractedHeritage {
-    filePath: string;
-    className: string;
-    parentName: string;
-    /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */
-    kind: string;
-}
 export interface ExtractedRoute {
     filePath: string;
     httpMethod: string;
@@ -140,10 +129,33 @@ export interface FileConstructorBindings {
     filePath: string;
     bindings: ConstructorBinding[];
 }
-/** File-scope type bindings from TypeEnv fixpoint — used for cross-file ExportedTypeMap. */
-export interface FileTypeEnvBindings {
+/** All-scope type bindings from TypeEnv — includes function-local scopes.
+ *  Used by BindingAccumulator for cross-file type propagation (Phase 9+).
+ *
+ *  Carries only file-scope entries (`scope = ''`). Serializing function-scope
+ *  bindings over IPC cost ~4.9 MB with zero downstream consumers.
+ *  `parse-worker.ts` now iterates only `typeEnv.fileScope()` and the
+ *  sequential path's `type-env.ts::flush()` is also narrowed to file
+ *  scope — see the `BindingAccumulator` class JSDoc for the unified
+ *  narrowing contract across both execution paths.
+ *
+ *  **Phase 9 reversion checklist** (when a downstream consumer of
+ *  function-scope bindings lands):
+ *    1. Change the loop in `runParseJob` below from `typeEnv.fileScope()`
+ *       back to `typeEnv.allScopes()`.
+ *    2. Emit three-element tuples `[scope, varName, typeName]`.
+ *    3. Widen the `bindings` field on this interface back to
+ *       `[string, string, string][]`.
+ *    4. Update the pipeline adapter in `pipeline.ts` to unpack three
+ *       elements and populate `BindingEntry.scope` from the first tuple
+ *       element instead of hardcoding `''`.
+ *    5. Also revert `type-env.ts::flush()` to iterate `env` instead of
+ *       just `FILE_SCOPE` if the sequential path needs function-scope data too.
+ *    6. Consider renaming this interface back to `FileAllScopeBindings`
+ *       along with widening. */
+export interface FileScopeBindings {
     filePath: string;
-    /** [varName, typeName] pairs from file scope (scope = '') */
+    /** [varName, typeName] pairs from the file scope only. */
     bindings: [string, string][];
 }
 export interface ParseWorkerResult {
@@ -160,8 +172,8 @@ export interface ParseWorkerResult {
     toolDefs: ExtractedToolDef[];
     ormQueries: ExtractedORMQuery[];
     constructorBindings: FileConstructorBindings[];
-    /** File-scope type bindings from TypeEnv fixpoint for exported symbol collection. */
-    typeEnvBindings: FileTypeEnvBindings[];
+    /** All-scope type bindings from TypeEnv for BindingAccumulator (includes function-local). */
+    fileScopeBindings: FileScopeBindings[];
     skippedLanguages: Record<string, number>;
     fileCount: number;
 }