gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -1,4 +1,4 @@
-import { parentPort } from 'node:worker_threads';
+import { parentPort, threadId, workerData } from 'node:worker_threads';
 import Parser from 'tree-sitter';
 import JavaScript from 'tree-sitter-javascript';
 import TypeScript from 'tree-sitter-typescript';
@@ -16,6 +16,7 @@ import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { getProvider } from '../languages/index.js';
 import { getTreeSitterBufferSize, getTreeSitterContentByteLength, TREE_SITTER_MAX_BUFFER, } from '../constants.js';
+import { ARRAY_METHOD_HOC_BLOCKLIST_SET, DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET, deriveDefaultExportHocName, } from '../ts-js-hoc-utils.js';
 import { parseSourceSafe } from '../../tree-sitter/safe-parse.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
@@ -37,18 +38,55 @@ try {
 }
 catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
-import { FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, genericFuncName, inferFunctionLabel, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
+import { buildConcreteTypedefDefinitionRanges, FUNCTION_NODE_TYPES, findAncestorBeforeBoundary, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, isQualifiableScopeLabel, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, PARAMETER_LIST_NODE_TYPES, LOCAL_SCOPE_BODY_NODE_TYPES, } from '../utils/ast-helpers.js';
 import { extractCallArgTypes } from '../utils/call-analysis.js';
 import { buildTypeEnv } from '../type-env.js';
 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, parameterShapeIdTag, } from '../utils/method-props.js';
-import { extractTemplateArguments, templateArgumentsIdTag } from '../utils/template-arguments.js';
+import { extractTemplateArguments, templateArgumentsIdTag, templateConstraintsIdTag, } from '../utils/template-arguments.js';
 import { extractParsedFile } from '../scope-extractor-bridge.js';
+import { persistParsedFileShardSync, persistDurableParsedFileShardSync, } from '../../../storage/parsedfile-store.js';
 import { extractLaravelRoutes } from '../route-extractors/laravel.js';
 import { logger } from '../../logger.js';
+// ── ParsedFile store (#1983 parallel serialization) ─────────────────────────
+// Read ONCE at worker init from `workerData` (immutable for the run, inherited
+// by respawned workers via the pool's factory closure). When set, this worker
+// writes its own ParsedFile shards to disk at each job flush instead of
+// returning them over the MessageChannel — parallelizing serialization off the
+// main thread. `undefined` ⇒ return ParsedFiles in the result (no-store
+// fallback). `shardSeq` makes each shard name unique within this worker; global
+// uniqueness for the run rests on the process-monotonic `threadId` (never reused
+// across respawns) plus the per-run store clear on the main thread.
+const PARSED_FILE_STORE_STORAGE_PATH = workerData?.parsedFileStoreStoragePath;
+// Durable, content-addressed ParsedFile store dir (#2038 warm-cache coverage).
+// When set AND the flush carries a chunk hash, the worker ALSO writes its
+// ParsedFiles to `<durableDir>/<chunkHash>/` so a future warm parse-cache hit
+// restores them without re-parsing. `undefined` ⇒ no durable write.
+const DURABLE_PARSED_FILE_STORAGE_PATH = workerData?.durableParsedFileStoragePath;
+let shardSeq = 0;
+// ── Bootstrap-stage diagnostics (#1741) ────────────────────────────────────
+// When GITNEXUS_WORKER_BOOTSTRAP=1 (or --verbose sets GITNEXUS_VERBOSE), each
+// worker reports its startup stage timings to stderr — which the pool tees
+// and captures (worker-pool.ts captureWorkerStderr). This makes a slow or
+// crashing startup diagnosable: you can see whether a worker reached
+// "grammars loaded", "ready sent", or never emitted a line at all (=> it
+// crashed in a native binding load before this code ran). The pool then
+// attaches whatever stderr it captured to its readiness-failure message,
+// so the operator sees the real cause instead of "did not report ready".
+const BOOTSTRAP_LOG = process.env.GITNEXUS_WORKER_BOOTSTRAP === '1' || process.env.GITNEXUS_VERBOSE === '1';
+const bootstrapStart = performance.now();
+const bootstrapLog = (stage) => {
+    if (!BOOTSTRAP_LOG)
+        return;
+    const ms = Math.round(performance.now() - bootstrapStart);
+    process.stderr.write(`[parse-worker bootstrap] thread=${threadId} ${stage} (+${ms}ms)\n`);
+};
+// First line we can emit: every static import above (tree-sitter native
+// bindings, language grammars, helper modules) has already resolved by the
+// time this module-body statement runs.
+bootstrapLog('imports + grammars loaded');
 // ============================================================================
 // Worker-local parser + language map
 // ============================================================================
@@ -278,7 +316,7 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const efnResult = provider.methodExtractor?.extractFunctionName?.(current);
+            const efnResult = provider.methodExtractor?.extractFunctionName?.(current, filePath);
             const funcName = efnResult?.funcName ?? genericFuncName(current);
             const label = efnResult?.label ?? inferFunctionLabel(current.type);
             if (funcName) {
@@ -399,11 +437,11 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
     return null;
 };
 /** Cached wrapper for findEnclosingClassInfo — avoids repeated parent walks. */
-const cachedFindEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) => {
+const cachedFindEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, getQualifiedOwnerName) => {
     const cached = classIdCache.get(node);
     if (cached !== undefined)
         return cached;
-    const result = findEnclosingClassInfo(node, filePath, resolveEnclosingOwner);
+    const result = findEnclosingClassInfo(node, filePath, resolveEnclosingOwner, getQualifiedOwnerName);
     classIdCache.set(node, result);
     return result;
 };
@@ -426,10 +464,8 @@ const processBatch = (files, onProgress) => {
         nodes: [],
         relationships: [],
         symbols: [],
-        imports: [],
         calls: [],
         assignments: [],
-        heritage: [],
         routes: [],
         fetchCalls: [],
         fetchWrapperDefs: [],
@@ -475,23 +511,16 @@ const processBatch = (files, onProgress) => {
         const queryString = provider.treeSitterQueries;
         if (!queryString) {
             // Standalone providers (regex-based, no tree-sitter) that implement
-            // emitScopeCaptures feed into the scope-resolution pipeline via
-            // extractParsedFile directly — no tree-sitter involved.
+            // emitScopeCaptures resolve via the scope-resolution pipeline, which
+            // re-extracts from source on the main thread.
             if (provider.emitScopeCaptures) {
-                for (const file of langFiles) {
-                    const parsedFile = extractParsedFile(provider, file.content, file.path, (message) => {
-                        if (parentPort) {
-                            parentPort.postMessage({ type: 'warning', message });
-                        }
-                        else {
-                            logger.warn(message);
-                        }
-                    }, undefined);
-                    if (parsedFile !== undefined) {
-                        result.parsedFiles.push(parsedFile);
-                        result.fileCount++;
-                        onFileProcessed?.();
-                    }
+                // The worker no longer builds `ParsedFile`s for standalone providers
+                // either — scope-resolution re-extracts on the main thread, and for
+                // standalone COBOL the graph nodes come from cobolPhase, not this
+                // artifact (#1983). Count one unit of progress per file, as before.
+                for (let i = 0; i < langFiles.length; i++) {
+                    result.fileCount++;
+                    onFileProcessed?.();
                 }
             }
             continue;
@@ -712,6 +741,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         }
         // Vue SFC preprocessing: extract <script> block content
         let parseContent = file.content;
+        let scopeSourceKind = 'full-file';
         let lineOffset = 0;
         let isVueSetup = false;
         if (language === SupportedLanguages.Vue) {
@@ -719,6 +749,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             if (!extracted)
                 continue; // skip .vue files with no script block
             parseContent = extracted.scriptContent;
+            scopeSourceKind = 'pre-extracted-script';
             lineOffset = extracted.lineOffset;
             isVueSetup = extracted.isSetup;
         }
@@ -747,13 +778,16 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             logger.warn(`Query execution failed for ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
             continue;
         }
+        const concreteTypedefRanges = buildConcreteTypedefDefinitionRanges(matches);
         const provider = getProvider(language);
-        // RFC #909 Ring 2: produce a `ParsedFile` for the new scope-based
-        // resolution pipeline. No-op (returns undefined) for every language
-        // today — only fires once a provider implements `emitScopeCaptures`.
-        // Runs BEFORE legacy extraction and its result is independent: a
-        // failure here is caught inside `extractParsedFile` and does NOT
-        // affect the legacy DAG path that follows.
+        // Produce the `ParsedFile` for the scope-resolution pipeline HERE, reusing
+        // the tree we just parsed (no second tree-sitter parse). Scope-resolution
+        // consumes these via the disk-backed parsedfile-store instead of
+        // re-extracting each file from source on the main thread — which
+        // accumulated an unbounded native tree-sitter leak on huge repos (#1983;
+        // see parsedfile-store.ts). parse-impl flushes `result.parsedFiles` to disk
+        // per chunk and does NOT retain them in main-thread heap, so this no longer
+        // costs ~1× the semantic model in RAM during parse.
         const parsedFile = extractParsedFile(provider, parseContent, file.path, (message) => {
             if (parentPort) {
                 parentPort.postMessage({ type: 'warning', message });
@@ -761,43 +795,34 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             else {
                 logger.warn(message);
             }
-        }, tree);
-        if (parsedFile !== undefined)
-            result.parsedFiles.push(parsedFile);
-        // Pre-pass: extract heritage from query matches to build parentMap for buildTypeEnv.
-        // Heritage edges (EXTENDS/IMPLEMENTS) are created by heritage-processor which runs
-        // in PARALLEL with call-processor, so the graph edges don't exist when buildTypeEnv
-        // runs. This pre-pass makes parent class information available for type resolution.
-        const fileParentMap = new Map();
-        if (provider.heritageExtractor) {
-            for (const match of matches) {
-                const captureMap = {};
-                for (const c of match.captures) {
-                    captureMap[c.name] = c.node;
-                }
-                if (captureMap['heritage.class']) {
-                    const heritageItems = provider.heritageExtractor.extract(captureMap, {
-                        filePath: file.path,
-                        language,
-                    });
-                    for (const item of heritageItems) {
-                        if (item.kind === 'extends') {
-                            let parents = fileParentMap.get(item.className);
-                            if (!parents) {
-                                parents = [];
-                                fileParentMap.set(item.className, parents);
-                            }
-                            if (!parents.includes(item.parentName))
-                                parents.push(item.parentName);
-                        }
-                    }
-                }
-            }
+        }, tree, scopeSourceKind);
+        if (parsedFile !== undefined) {
+            // Capture-time side-channel (#1983): `extractParsedFile` just ran the
+            // provider's `emitScopeCaptures`, which (for C++ ADL/namespace marks,
+            // C `static`-linkage names, and Kotlin companion scopes) populated
+            // module-level maps as a SIDE EFFECT that is NOT on `parsedFile`'s
+            // scopes/defs. Snapshot
+            // that per-file state as plain data onto `ParsedFile.captureSideChannel`
+            // so the main thread can restore it (via `ScopeResolver.applyCaptureSideChannel`)
+            // WITHOUT a re-parse, after this ParsedFile crosses the worker boundary /
+            // disk store. Providers without capture-time side effects leave the hook
+            // undefined and this is a no-op. `undefined` return ⇒ no field added.
+            //
+            // `extractParsedFile` returns a frozen ParsedFile, so re-wrap (shallow
+            // copy — scopes/defs are carried by reference) to attach the field rather
+            // than mutate the frozen object.
+            const sideChannel = provider.collectCaptureSideChannel?.(file.path);
+            result.parsedFiles.push(sideChannel !== undefined ? { ...parsedFile, captureSideChannel: sideChannel } : parsedFile);
         }
         // Build per-file type environment + constructor bindings in a single AST walk.
-        // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
-        const parentMap = fileParentMap;
+        // The legacy heritage pre-pass that seeded a file-local parentMap for
+        // buildTypeEnv was removed in RING4-1 (#942) along with the rest of the
+        // call-resolution DAG. Inheritance is now emitted by scope-resolution
+        // (preEmitInheritanceEdges + @reference.inherits), so buildTypeEnv runs with
+        // an empty parentMap — cross-file inheritance was never resolved here anyway.
+        const parentMap = new Map();
         const typeEnv = buildTypeEnv(tree, language, {
+            filePath: file.path,
             parentMap,
             enclosingFunctionFinder: provider?.enclosingFunctionFinder,
             extractFunctionName: provider?.methodExtractor?.extractFunctionName,
@@ -833,24 +858,18 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // (e.g. @definition.function) to avoid duplicate nodes when @definition.const/@definition.variable
         // patterns overlap with the same source range.
         const processedDefinitionNodes = new Set();
+        const variableInfoCache = new Map();
         for (const match of matches) {
             const captureMap = {};
             for (const c of match.captures) {
                 captureMap[c.name] = c.node;
             }
-            // Extract import paths before skipping
+            if (isSuppressedConcreteTypedefDuplicate(captureMap, concreteTypedefRanges))
+                continue;
+            // Import matches: IMPORTS edges are emitted by the scope-resolution
+            // phase from finalized ImportEdges (RING4-1 #942 / RING4-2 #943 removed
+            // the legacy per-file import-map extraction that ran here). Skip.
             if (captureMap['import'] && captureMap['import.source']) {
-                const rawImportPath = preprocessImportPath(captureMap['import.source'].text, captureMap['import'], provider);
-                if (!rawImportPath)
-                    continue;
-                const extractor = provider.namedBindingExtractor;
-                const namedBindings = extractor ? extractor(captureMap['import']) : undefined;
-                result.imports.push({
-                    filePath: file.path,
-                    rawImportPath,
-                    language: language,
-                    ...(namedBindings ? { namedBindings } : {}),
-                });
                 continue;
             }
             // Extract assignment sites (field write access)
@@ -1043,38 +1062,31 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     // ── Path 2: Generic extraction via @call.name ────────────────
                     if (callNameNode) {
                         const calledName = callNameNode.text;
-                        // Check heritage extractor for call-based heritage (e.g., Ruby include/extend/prepend)
-                        if (provider.heritageExtractor?.extractFromCall) {
-                            const heritageItems = provider.heritageExtractor.extractFromCall(calledName, callNode, { filePath: file.path, language });
-                            if (heritageItems !== null) {
-                                for (const item of heritageItems) {
-                                    result.heritage.push({
-                                        filePath: file.path,
-                                        className: item.className,
-                                        parentName: item.parentName,
-                                        kind: item.kind,
-                                    });
-                                }
-                                continue;
-                            }
-                        }
-                        // Dispatch: route language-specific calls (properties, imports)
-                        // Heritage routing is handled by heritageExtractor.extractFromCall above.
+                        // Dispatch: route language-specific calls (properties, imports).
+                        // Call-based heritage (Ruby include/extend/prepend) is no longer
+                        // routed here — those calls return 'skip' from the router and the
+                        // mixin edges are emitted by scope-resolution (emitHeritageEdges).
                         const routed = callRouter?.(calledName, captureMap['call']);
                         if (routed) {
                             if (routed.kind === 'skip')
                                 continue;
                             if (routed.kind === 'import') {
-                                result.imports.push({
-                                    filePath: file.path,
-                                    rawImportPath: routed.importPath,
-                                    language,
-                                });
+                                // Call-routed imports (e.g. Ruby `require`) are emitted as
+                                // IMPORTS edges by the scope-resolution phase; the legacy
+                                // per-file extraction that consumed these was removed in
+                                // RING4-2 (#943). Skip.
                                 continue;
                             }
                             if (routed.kind === 'properties') {
-                                const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
-                                const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
+                                // #1978: thread the qualifier so a routed property's owner edge
+                                // points at the *qualified* nested-class node (Outer.Inner) rather
+                                // than a now-nonexistent simple `Class:file:Inner` id. Gated on the
+                                // flag → byte-identical when off. Mirrors the main owner path.
+                                const propGetQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
+                                    ? (node, simpleName) => provider.classExtractor.extractQualifiedName(node, simpleName)
+                                    : undefined;
+                                const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner, propGetQualifiedOwnerName);
+                                const propEnclosingClassId = propEnclosingInfo?.qualifiedClassId ?? propEnclosingInfo?.classId ?? null;
                                 // Enrich routed properties with FieldExtractor metadata
                                 let routedFieldMap;
                                 if (provider.fieldExtractor && typeEnv) {
@@ -1142,16 +1154,20 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                             ? { isReadonly: routedFieldInfo.isReadonly }
                                             : {}),
                                     });
-                                    const fileId = generateId('File', file.path);
-                                    const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-                                    result.relationships.push({
-                                        id: relId,
-                                        sourceId: fileId,
-                                        targetId: nodeId,
-                                        type: 'DEFINES',
-                                        confidence: 1.0,
-                                        reason: '',
-                                    });
+                                    // Only emit File -> Property DEFINES for top-level properties
+                                    // (issue #1944); class members are reached via HAS_PROPERTY.
+                                    if (!propEnclosingClassId) {
+                                        const fileId = generateId('File', file.path);
+                                        const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+                                        result.relationships.push({
+                                            id: relId,
+                                            sourceId: fileId,
+                                            targetId: nodeId,
+                                            type: 'DEFINES',
+                                            confidence: 1.0,
+                                            reason: '',
+                                        });
+                                    }
                                     if (propEnclosingClassId) {
                                         result.relationships.push({
                                             id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
@@ -1210,35 +1226,6 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 }
                 continue;
             }
-            // Extract heritage (extends/implements) via provider heritage extractor
-            if (captureMap['heritage.class']) {
-                if (provider.heritageExtractor) {
-                    const heritageItems = provider.heritageExtractor.extract(captureMap, {
-                        filePath: file.path,
-                        language,
-                    });
-                    for (const item of heritageItems) {
-                        result.heritage.push({
-                            filePath: file.path,
-                            className: item.className,
-                            parentName: item.parentName,
-                            kind: item.kind,
-                        });
-                    }
-                    // When the extractor consumes the match, skip symbol processing below.
-                    if (heritageItems.length > 0) {
-                        continue;
-                    }
-                }
-                // Fallback: the extractor returned [] (or is absent), but the match still
-                // carries a heritage-specific capture. The match belongs to a heritage
-                // clause and must not fall through to generic symbol processing.
-                if (captureMap['heritage.extends'] ||
-                    captureMap['heritage.implements'] ||
-                    captureMap['heritage.trait']) {
-                    continue;
-                }
-            }
             const definitionNode = getDefinitionNodeFromCaptures(captureMap);
             const defaultNodeLabel = getLabelFromCaptures(captureMap, provider);
             if (!defaultNodeLabel)
@@ -1265,21 +1252,52 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 }) === true) {
                 continue;
             }
+            const exportDefaultCall = nodeLabel === 'Function' && definitionNode?.type === 'export_statement'
+                ? definitionNode.namedChildren.find((child) => child.type === 'call_expression')
+                : undefined;
+            const defaultExportHocName = (() => {
+                if (exportDefaultCall === undefined)
+                    return null;
+                const argList = exportDefaultCall.childForFieldName?.('arguments');
+                const callback = argList?.namedChildren.find((child) => child.type === 'arrow_function' || child.type === 'function_expression');
+                if (callback === undefined)
+                    return null;
+                const callee = exportDefaultCall.childForFieldName?.('function');
+                if (callee?.type === 'identifier' &&
+                    DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET.has(callee.text))
+                    return null;
+                if (callee?.type === 'member_expression') {
+                    const property = callee.childForFieldName?.('property');
+                    if (property?.type === 'property_identifier' &&
+                        ARRAY_METHOD_HOC_BLOCKLIST_SET.has(property.text))
+                        return null;
+                }
+                return deriveDefaultExportHocName(file.path);
+            })();
+            // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
+            if (!nameNode &&
+                nodeLabel !== 'Constructor' &&
+                !extractedClassSymbol &&
+                !defaultExportHocName)
+                continue;
+            const nodeName = extractedClassSymbol?.name ?? defaultExportHocName ?? (nameNode ? nameNode.text : 'init');
             // Dedup: variable captures (Const/Static/Variable) may overlap with higher-priority
             // captures (e.g. `const fn = () => {}` matches both @definition.function and @definition.const).
-            // Skip variable captures whose definition node was already processed.
-            if ((nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') &&
-                definitionNode &&
-                processedDefinitionNodes.has(definitionNode.startIndex)) {
-                continue;
-            }
+            // Multi-name declarations share the same definition node, so include the emitted name.
             if (definitionNode) {
-                processedDefinitionNodes.add(definitionNode.startIndex);
+                const definitionBaseKey = `${definitionNode.startIndex}`;
+                if (nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') {
+                    const definitionNameKey = `${definitionBaseKey}:${nodeName}`;
+                    if (processedDefinitionNodes.has(definitionBaseKey) ||
+                        processedDefinitionNodes.has(definitionNameKey)) {
+                        continue;
+                    }
+                    processedDefinitionNodes.add(definitionNameKey);
+                }
+                else {
+                    processedDefinitionNodes.add(definitionBaseKey);
+                }
             }
-            // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
-            if (!nameNode && nodeLabel !== 'Constructor' && !extractedClassSymbol)
-                continue;
-            const nodeName = extractedClassSymbol?.name ?? (nameNode ? nameNode.text : 'init');
             const startLine = definitionNode
                 ? definitionNode.startPosition.row + lineOffset
                 : nameNode
@@ -1290,17 +1308,93 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 nodeLabel === 'Constructor' ||
                 nodeLabel === 'Property' ||
                 nodeLabel === 'Function';
-            const enclosingClassInfo = needsOwner
-                ? cachedFindEnclosingClassInfo(nameNode || definitionNode, file.path, provider.resolveEnclosingOwner)
+            // #1978: thread the class-extractor's qualifier into the owner walk when the
+            // language opts into qualified node ids, so a nested member's owner resolves
+            // to the *qualified* class id (Outer.Inner). Gated on the flag → byte-identical
+            // when off. Mirrors parsing-processor.ts.
+            const getQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
+                ? (node, simpleName) => 
+                // #1991: LOCKSTEP — a Ruby `module` owner is not a typeDeclaration, so
+                // extractQualifiedName returns null; fall back to the scope walk so a
+                // method inside a nested module owns through the SAME qualified Trait
+                // id its node uses on the worker path too.
+                provider.classExtractor.extractQualifiedName(node, simpleName) ??
+                    provider.classExtractor.qualifyScopeName?.(node, simpleName) ??
+                    null
+                : undefined;
+            // A Property declared inside a function/lambda BODY is a function-LOCAL
+            // binding (e.g. Kotlin `val (a,b) = pair` or a `for ((k,v) in m)` loop
+            // destructuring emitted as `@definition.property` to dodge the local-symbol
+            // pruner), NOT a class member. Such locals must not get a HAS_PROPERTY owner
+            // edge from the enclosing class. Detect them by walking from the def node:
+            // if a function-like ancestor is reached BEFORE any class container, the
+            // property is enclosed by a function. Language-agnostic — genuine class
+            // fields sit directly in the class body with no intervening function, so
+            // they are unaffected (#1919 review CF3).
+            //
+            // EXCEPTION: a constructor PARAMETER property (TypeScript
+            // `constructor(public name: string)`) is also enclosed by a function, but
+            // it IS a class member — it is reached through the parameter list, not the
+            // executable body. So only strip the owner when the property is NOT inside
+            // a parameter list of that function (i.e. it's a body local).
+            const propOwnerNode = nameNode || definitionNode;
+            // A Property is function-local (and must NOT get a class HAS_PROPERTY owner)
+            // when its nearest enclosing executable body — reached before any class
+            // container — is a function/accessor/initializer body, AND it is not a
+            // constructor parameter-property (rescued by the param-list carve-out).
+            // Uses LOCAL_SCOPE_BODY_NODE_TYPES (not FUNCTION_NODE_TYPES): the latter
+            // mis-includes Dart bare signatures (over-stripping accessors) and omits
+            // Kotlin/Swift init+accessor bodies (under-stripping their locals) — see
+            // the #1919 review of this guard.
+            const isFunctionLocalProperty = nodeLabel === 'Property' &&
+                propOwnerNode !== undefined &&
+                findAncestorBeforeBoundary(propOwnerNode, LOCAL_SCOPE_BODY_NODE_TYPES, CLASS_CONTAINER_TYPES) !== null &&
+                findAncestorBeforeBoundary(propOwnerNode, PARAMETER_LIST_NODE_TYPES, LOCAL_SCOPE_BODY_NODE_TYPES) === null;
+            const enclosingClassInfo = needsOwner && !isFunctionLocalProperty
+                ? cachedFindEnclosingClassInfo(nameNode || definitionNode, file.path, provider.resolveEnclosingOwner, getQualifiedOwnerName)
                 : null;
-            const enclosingClassId = enclosingClassInfo?.classId ?? null;
+            const enclosingClassId = enclosingClassInfo?.qualifiedClassId ?? enclosingClassInfo?.classId ?? null;
             const objectLiteralOwnerInfo = !enclosingClassId && nodeLabel === 'Method' && definitionNode
                 ? findObjectLiteralBindingInfo(definitionNode, file.path)
                 : null;
-            // Qualify method/property IDs with enclosing class name to avoid collisions
-            const qualifiedName = enclosingClassInfo
-                ? `${enclosingClassInfo.className}.${nodeName}`
-                : nodeName;
+            // #1978: hoisted ABOVE qualifiedName/node-id (load-bearing order) so a
+            // class-like node can key its id by its fully-qualified path. Derived from
+            // the SAME extractQualifiedName the owner edge uses → owner id == node id.
+            const classNodeForSymbol = definitionNode || nameNode;
+            const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
+                (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
+                    ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
+                    : // #1991: LOCKSTEP with parsing-processor.ts — qualify a Ruby `module`
+                        // (Trait) via the scope walk so same-tail nested mixin modules get
+                        // distinct ids on the worker path too. Gated on qualifiedNodeId.
+                        isQualifiableScopeLabel(nodeLabel) &&
+                            provider.classExtractor?.qualifiedNodeId === true &&
+                            classNodeForSymbol
+                            ? (provider.classExtractor.qualifyScopeName?.(classNodeForSymbol, nodeName) ??
+                                undefined)
+                            : undefined);
+            // Qualify method/property IDs with enclosing class name to avoid collisions.
+            // Class-like nodes use their own fully-qualified path as the id key when the
+            // language enables qualifiedNodeId (#1978); everything else is unchanged.
+            // #1982: LOCKSTEP with parsing-processor.ts — a Rust inherent-impl with an
+            // UNSCOPED bare target is keyed by the enclosing `mod_item` scope so the
+            // worker-path Impl node id matches the sequential path and the owner walk.
+            const rustImplQualifiedName = nodeLabel === 'Impl' &&
+                definitionNode?.type === 'impl_item' &&
+                nameNode?.type === 'type_identifier'
+                ? qualifyRustImplTargetByModScope(definitionNode, nodeName)
+                : undefined;
+            const qualifiedName = rustImplQualifiedName !== undefined
+                ? rustImplQualifiedName
+                : // #1991: LOCKSTEP — include Trait so a Ruby mixin module's qualified
+                    // scope id keys the worker-path node, matching the sequential path.
+                    (isClassLikeLabel || isQualifiableScopeLabel(nodeLabel)) &&
+                        provider.classExtractor?.qualifiedNodeId === true &&
+                        qualifiedTypeName !== undefined
+                        ? qualifiedTypeName
+                        : enclosingClassInfo
+                            ? `${enclosingClassInfo.className}.${nodeName}`
+                            : nodeName;
             // Extract method metadata BEFORE generating node ID — parameterCount is needed
             // to disambiguate overloaded methods via #<arity> suffix in the ID.
             let declaredType;
@@ -1379,12 +1473,35 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 classTemplateArguments.length > 0
                 ? templateArgumentsIdTag(classTemplateArguments)
                 : '';
-            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${parameterShapeTag}`);
-            const classNodeForSymbol = definitionNode || nameNode;
-            const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
-                (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
-                    ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
-                    : undefined);
+            // SFINAE / `requires`-clause aware ID disambiguation (issue #1579).
+            // Function-template overloads with identical parameterTypes but
+            // mutually-exclusive constraints (e.g. `enable_if_t<is_integral_v<T>>`
+            // vs `enable_if_t<is_floating_point_v<T>>`) need distinct graph nodes
+            // so the constraint-filter step in `narrowOverloadCandidates` has two
+            // candidates to narrow between. Without this tag they collapse to a
+            // single Function node and the SFINAE call resolves to only one edge
+            // regardless of which overload's constraint holds. This mirrors the
+            // sequential `parsing-processor` path removed in #1983 — the worker is
+            // now the sole parse path, so it must stamp the constraint tag and the
+            // `templateConstraints` node property the resolver looks up by re-
+            // hashing the def's constraints (see graph-bridge ids.ts / node-lookup.ts).
+            let parsedTemplateConstraints = undefined;
+            let constraintsTag = '';
+            if ((nodeLabel === 'Function' || nodeLabel === 'Method') &&
+                provider.extractTemplateConstraints !== undefined &&
+                definitionNode) {
+                try {
+                    parsedTemplateConstraints = provider.extractTemplateConstraints(definitionNode);
+                    if (parsedTemplateConstraints !== undefined) {
+                        constraintsTag = templateConstraintsIdTag(parsedTemplateConstraints);
+                    }
+                }
+                catch {
+                    parsedTemplateConstraints = undefined;
+                    constraintsTag = '';
+                }
+            }
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${parameterShapeTag}${constraintsTag}`);
             const description = provider.descriptionExtractor?.(nodeLabel, nodeName, captureMap);
             let frameworkHint = definitionNode
                 ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
@@ -1460,11 +1577,18 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             if ((nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') &&
                 definitionNode &&
                 provider.variableExtractor) {
-                const varCtx = {
-                    filePath: file.path,
-                    language,
-                };
-                const varInfo = provider.variableExtractor.extract(definitionNode, varCtx);
+                let variableInfoByName = variableInfoCache.get(definitionNode.startIndex);
+                if (!variableInfoByName) {
+                    const varCtx = {
+                        filePath: file.path,
+                        language,
+                    };
+                    variableInfoByName = new Map(provider.variableExtractor
+                        .extractAll(definitionNode, varCtx)
+                        .map((info) => [info.name, info]));
+                    variableInfoCache.set(definitionNode.startIndex, variableInfoByName);
+                }
+                const varInfo = variableInfoByName.get(nodeName);
                 if (varInfo) {
                     if (varInfo.type)
                         declaredType = varInfo.type;
@@ -1491,6 +1615,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     ...(classTemplateArguments !== undefined && classTemplateArguments.length > 0
                         ? { templateArguments: classTemplateArguments }
                         : {}),
+                    ...(parsedTemplateConstraints !== undefined
+                        ? { templateConstraints: parsedTemplateConstraints }
+                        : {}),
                     ...(frameworkHint
                         ? {
                             astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
@@ -1539,16 +1666,19 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     ? { annotations: methodProps.annotations }
                     : {}),
             });
-            const fileId = generateId('File', file.path);
-            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-            result.relationships.push({
-                id: relId,
-                sourceId: fileId,
-                targetId: nodeId,
-                type: 'DEFINES',
-                confidence: 1.0,
-                reason: '',
-            });
+            // Only emit File -> Symbol DEFINES for top-level symbols (issue #1944).
+            if (ownerId === undefined) {
+                const fileId = generateId('File', file.path);
+                const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+                result.relationships.push({
+                    id: relId,
+                    sourceId: fileId,
+                    targetId: nodeId,
+                    type: 'DEFINES',
+                    confidence: 1.0,
+                    reason: '',
+                });
+            }
             // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ──
             if (ownerId !== undefined) {
                 const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD';
@@ -1613,10 +1743,8 @@ let accumulated = {
     nodes: [],
     relationships: [],
     symbols: [],
-    imports: [],
     calls: [],
     assignments: [],
-    heritage: [],
     routes: [],
     fetchCalls: [],
     fetchWrapperDefs: [],
@@ -1644,10 +1772,8 @@ const mergeResult = (target, src) => {
     appendAll(target.nodes, src.nodes);
     appendAll(target.relationships, src.relationships);
     appendAll(target.symbols, src.symbols);
-    appendAll(target.imports, src.imports);
     appendAll(target.calls, src.calls);
     appendAll(target.assignments, src.assignments);
-    appendAll(target.heritage, src.heritage);
     appendAll(target.routes, src.routes);
     appendAll(target.fetchCalls, src.fetchCalls);
     appendAll(target.fetchWrapperDefs, src.fetchWrapperDefs);
@@ -1685,6 +1811,7 @@ const mergeResult = (target, src) => {
 // `WORKER_READY_TIMEOUT_MS` (5s), so emitting it AFTER all top-of-script
 // init (imports, native binding loads, type-env setup) completes is the
 // load-bearing signal that this worker is ready for dispatch.
+bootstrapLog('ready sent');
 parentPort.postMessage({ type: 'ready' });
 // Module-scope `TextDecoder` for sub-batch content. The pool sends each
 // file's content as a `Uint8Array` (zero-copy ArrayBuffer transfer); we
@@ -1710,7 +1837,12 @@ function decodeSubBatchFiles(files) {
         content: typeof f.content === 'string' ? f.content : sharedContentDecoder.decode(f.content),
     }));
 }
+let firstTaskLogged = false;
 parentPort.on('message', (msg) => {
+    if (!firstTaskLogged) {
+        firstTaskLogged = true;
+        bootstrapLog('first task received');
+    }
     try {
         // Sub-batch mode: { type: 'sub-batch', files: [...] }
         if (msg.type === 'sub-batch') {
@@ -1729,16 +1861,41 @@ parentPort.on('message', (msg) => {
         }
         // Flush: send accumulated results
         if (msg.type === 'flush') {
+            // #1983 parallel serialization: when a store path is configured, write
+            // this job's ParsedFiles to our own disk shard HERE (at the flush
+            // boundary, where `accumulated.parsedFiles` is complete) and drop them
+            // from the result so the main thread never deserializes/re-serializes
+            // them. Writing at flush — not per sub-batch — encodes the invariant
+            // "a shard is written iff its result is delivered": a worker that dies
+            // before flush wrote no shard, so the pool's job retry yields exactly
+            // one. `undefined` store path keeps ParsedFiles in the result (no-store
+            // fallback). The write is synchronous: blocking this dedicated worker
+            // thread protects the main thread and avoids threading async through the
+            // accumulate path; per-job write time is small vs the parse it follows.
+            if ((PARSED_FILE_STORE_STORAGE_PATH || DURABLE_PARSED_FILE_STORAGE_PATH) &&
+                accumulated.parsedFiles.length > 0) {
+                const seq = shardSeq++;
+                // #2038 warm-cache coverage: ALSO write a durable, content-addressed
+                // shard keyed by chunk hash so a future warm parse-cache hit (no worker
+                // runs) can restore these ParsedFiles without re-parsing. Same bytes,
+                // same `seq`, so durable and run-scoped shards correlate. Only when the
+                // flush carried a chunk hash (content-addressed dispatch).
+                if (DURABLE_PARSED_FILE_STORAGE_PATH && typeof msg.chunkHash === 'string') {
+                    persistDurableParsedFileShardSync(DURABLE_PARSED_FILE_STORAGE_PATH, msg.chunkHash, threadId, seq, accumulated.parsedFiles);
+                }
+                if (PARSED_FILE_STORE_STORAGE_PATH) {
+                    persistParsedFileShardSync(PARSED_FILE_STORE_STORAGE_PATH, `w${threadId}-${seq}`, accumulated.parsedFiles);
+                    accumulated.parsedFiles = [];
+                }
+            }
             parentPort.postMessage({ type: 'result', data: accumulated });
             // Reset for potential reuse
             accumulated = {
                 nodes: [],
                 relationships: [],
                 symbols: [],
-                imports: [],
                 calls: [],
                 assignments: [],
-                heritage: [],
                 routes: [],
                 fetchCalls: [],
                 fetchWrapperDefs: [],
@@ -1759,7 +1916,21 @@ parentPort.on('message', (msg) => {
         }
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        parentPort.postMessage({ type: 'error', error: message });
+        // Carry the worker-side stack across the MessageChannel, not just the
+        // message. Without this, an unexpected worker throw (e.g. the minified
+        // `this.#<x> is not a function` family) reaches the operator as a bare
+        // one-liner with no file:line — exactly what made #2068 undebuggable. The
+        // pool embeds `errorStack` into its death/circuit-breaker reason so the
+        // surfaced "Phase 'parse' failed" message points at the real frame (the
+        // stack's first line already carries the error's type + message). We send
+        // primitive fields (not the raw Error) so a non-cloneable `cause` payload
+        // can never turn the report itself into a `messageerror`. `errorStack` is
+        // optional on the wire, so an older pool ignores it.
+        const e = err instanceof Error ? err : new Error(String(err));
+        parentPort.postMessage({
+            type: 'error',
+            error: e.message,
+            errorStack: e.stack,
+        });
     }
 });