gitnexus 1.6.6-rc.156 → 1.6.6-rc.158

package/dist/cli/analyze.js

@@ -41,6 +41,22 @@ const writeFatalToStderr = (label, err) => {
     realStderrWrite(`\n  ${label}: ${message}\n`);
     if (isErr && err.stack)
         realStderrWrite(`${err.stack}\n`);
+    // Walk and print the `cause` chain. The phase runner wraps the underlying
+    // failure as `new Error("Phase 'X' failed: …", { cause })`, so the original
+    // error (e.g. a WorkerPoolDispatchError carrying the worker-side stack from
+    // #2068) is only reachable via `.cause`. Without this the user sees the
+    // wrapper's main-thread stack and never the real frame. `cause.stack` already
+    // begins with the cause's message, so we print the stack alone (not message +
+    // stack) to avoid repeating it. Depth-bounded so a cyclic `cause` can't loop
+    // (the phase runner wraps one level; the bound leaves headroom for future
+    // nesting); uses realStderrWrite so the redirected console.error's ANSI
+    // clear-line wrapping can't erase it (#1169).
+    const MAX_CAUSE_DEPTH = 5;
+    let cause = isErr ? err.cause : undefined;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH && cause instanceof Error; depth++) {
+        realStderrWrite(`\n  Caused by: ${cause.stack ?? cause.message}\n`);
+        cause = cause.cause;
+    }
 };
 let fatalHandlersInstalled = false;
 /**

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

@@ -9,14 +9,12 @@
  *
  *   - `processRoutesFromExtracted` — CALLS edges from framework routes
  *     (e.g. Laravel) to their controller methods.
- *   - `processNextjsFetchRoutes` / `extractFetchCallsFromFiles` /
- *     `extractConsumerAccessedKeys` — FETCHES edges from `fetch()` calls to
- *     Next.js Route nodes.
+ *   - `processNextjsFetchRoutes` / `extractConsumerAccessedKeys` — FETCHES edges
+ *     from `fetch()` calls to Next.js Route nodes.
  *   - `buildExportedTypeMapFromGraph` — exported symbol → return/declared type
  *     map, consumed by the cross-file enrichment pass.
  */
 import { KnowledgeGraph } from '../graph/types.js';
-import { ASTCache } from './ast-cache.js';
 import type { SemanticModel, SymbolTableReader } from './model/index.js';
 import type { ExtractedRoute, ExtractedFetchCall } from './workers/parse-worker.js';
 /** Per-file resolved type bindings for exported symbols.
@@ -76,12 +74,3 @@ export declare const extractConsumerAccessedKeys: (content: string) => string[];
  */
 export declare const processNextjsFetchRoutes: (graph: KnowledgeGraph, fetchCalls: ExtractedFetchCall[], routeRegistry: Map<string, string>, // routeURL → handlerFilePath
 consumerContents?: Map<string, string>) => void;
-/**
- * Extract fetch() calls from source files (sequential path).
- * Workers handle this via tree-sitter captures in parse-worker; this function
- * provides the same extraction for the sequential fallback path.
- */
-export declare const extractFetchCallsFromFiles: (files: {
-    path: string;
-    content: string;
-}[], astCache: ASTCache) => Promise<ExtractedFetchCall[]>;

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

@@ -9,20 +9,13 @@
  *
  *   - `processRoutesFromExtracted` — CALLS edges from framework routes
  *     (e.g. Laravel) to their controller methods.
- *   - `processNextjsFetchRoutes` / `extractFetchCallsFromFiles` /
- *     `extractConsumerAccessedKeys` — FETCHES edges from `fetch()` calls to
- *     Next.js Route nodes.
+ *   - `processNextjsFetchRoutes` / `extractConsumerAccessedKeys` — FETCHES edges
+ *     from `fetch()` calls to Next.js Route nodes.
  *   - `buildExportedTypeMapFromGraph` — exported symbol → return/declared type
  *     map, consumed by the cross-file enrichment pass.
  */
-import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
-import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from '../../_shared/index.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
-import { getTreeSitterBufferSize } from './constants.js';
 import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractReturnTypeName } from './type-extractors/shared.js';
 const MAX_EXPORTS_PER_FILE = 500;
@@ -408,73 +401,3 @@ consumerContents) => {
         }
     }
 };
-/**
- * Extract fetch() calls from source files (sequential path).
- * Workers handle this via tree-sitter captures in parse-worker; this function
- * provides the same extraction for the sequential fallback path.
- */
-export const extractFetchCallsFromFiles = async (files, astCache) => {
-    const parser = await loadParser();
-    const result = [];
-    for (const file of files) {
-        const language = getLanguageFromFilename(file.path);
-        if (!language)
-            continue;
-        if (!isLanguageAvailable(language))
-            continue;
-        const provider = getProvider(language);
-        const queryStr = provider.treeSitterQueries;
-        if (!queryStr)
-            continue;
-        await loadLanguage(language, file.path);
-        let tree = astCache.get(file.path);
-        if (!tree) {
-            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
-            try {
-                tree = parseSourceSafe(parser, parseContent, undefined, {
-                    bufferSize: getTreeSitterBufferSize(parseContent),
-                });
-            }
-            catch {
-                continue;
-            }
-            astCache.set(file.path, tree);
-        }
-        let matches;
-        try {
-            const lang = parser.getLanguage();
-            const query = new Parser.Query(lang, queryStr);
-            matches = query.matches(tree.rootNode);
-        }
-        catch {
-            continue;
-        }
-        for (const match of matches) {
-            const captureMap = {};
-            match.captures.forEach((c) => (captureMap[c.name] = c.node));
-            if (captureMap['route.fetch']) {
-                const urlNode = captureMap['route.url'] ?? captureMap['route.template_url'];
-                if (urlNode) {
-                    result.push({
-                        filePath: file.path,
-                        fetchURL: urlNode.text,
-                        lineNumber: captureMap['route.fetch'].startPosition.row,
-                    });
-                }
-            }
-            else if (captureMap['http_client'] && captureMap['http_client.url']) {
-                const method = captureMap['http_client.method']?.text;
-                const url = captureMap['http_client.url'].text;
-                const HTTP_CLIENT_ONLY = new Set(['head', 'options', 'request', 'ajax']);
-                if (method && HTTP_CLIENT_ONLY.has(method) && url.startsWith('/')) {
-                    result.push({
-                        filePath: file.path,
-                        fetchURL: url,
-                        lineNumber: captureMap['http_client'].startPosition.row,
-                    });
-                }
-            }
-        }
-    }
-    return result;
-};

package/dist/core/ingestion/export-detection.d.ts

@@ -4,7 +4,8 @@
  * Determines whether a symbol (function, class, etc.) is exported/public
  * in its language. This is a pure function — safe for use in worker threads.
  *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ * Used by the language providers during worker parsing (parse-worker.ts) — the
+ * sole parse path. (Sequential parsing was removed.)
  */
 import { type SyntaxNode } from './utils/ast-helpers.js';
 /** Handler type: given a node and symbol name, return true if the symbol is exported/public. */

package/dist/core/ingestion/export-detection.js

@@ -4,7 +4,8 @@
  * Determines whether a symbol (function, class, etc.) is exported/public
  * in its language. This is a pure function — safe for use in worker threads.
  *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ * Used by the language providers during worker parsing (parse-worker.ts) — the
+ * sole parse path. (Sequential parsing was removed.)
  */
 import { findSiblingChild } from './utils/ast-helpers.js';
 // ============================================================================

package/dist/core/ingestion/field-extractors/configs/dart.d.ts

@@ -1,8 +1,2 @@
 import type { FieldExtractionConfig } from '../generic.js';
-/**
- * Dart field extraction config.
- *
- * Dart class fields appear as declaration nodes inside class_body.
- * Visibility is convention-based: underscore prefix = private.
- */
 export declare const dartConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/dart.js

@@ -5,41 +5,68 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 /**
  * Dart field extraction config.
  *
- * Dart class fields appear as declaration nodes inside class_body.
+ * Dart class fields appear as `declaration` nodes inside `class_body`.
+ * Two shapes carry the field name(s):
+ *   - instance / plain fields → `initialized_identifier_list`
+ *     (`int z = 0;`, `int a = 1, b = 2;`)
+ *   - `static const` / `static final` / `const` fields → `static_final_declaration_list`
+ *     (`static const a = 1;`, `static final String b = 'x', c = 'y';`)
+ * Both shapes may declare SEVERAL fields in one declaration, so name extraction
+ * is multi-name (`extractNames`). The structure query (`DART_QUERIES`) emits one
+ * `@definition.property` per name for both shapes; this config enriches each.
+ *
  * Visibility is convention-based: underscore prefix = private.
  */
+/** All field names declared by a `declaration` node, across both Dart shapes. */
+function extractDartFieldNames(node) {
+    const names = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        // instance / plain fields: initialized_identifier_list > initialized_identifier > identifier
+        if (child.type === 'initialized_identifier_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const init = child.namedChild(j);
+                if (init?.type === 'initialized_identifier') {
+                    const ident = init.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+        // static const / final fields: static_final_declaration_list > static_final_declaration > identifier
+        if (child.type === 'static_final_declaration_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const decl = child.namedChild(j);
+                if (decl?.type === 'static_final_declaration') {
+                    const ident = decl.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+    }
+    return names;
+}
 export const dartConfig = {
     language: SupportedLanguages.Dart,
     typeDeclarationNodes: ['class_definition'],
     fieldNodeTypes: ['declaration'],
     bodyNodeTypes: ['class_body'],
     defaultVisibility: 'public',
+    // One AST `declaration` node may declare several fields (`int a, b;`,
+    // `static final String b = 'x', c = 'y';`), so use the multi-name path.
     extractName(node) {
-        // declaration > initialized_identifier_list > initialized_identifier > identifier
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'initialized_identifier_list') {
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const init = child.namedChild(j);
-                    if (init?.type === 'initialized_identifier') {
-                        const ident = init.firstNamedChild;
-                        if (ident?.type === 'identifier')
-                            return ident.text;
-                    }
-                }
-            }
-            if (child?.type === 'initialized_identifier') {
-                const ident = child.firstNamedChild;
-                if (ident?.type === 'identifier')
-                    return ident.text;
-            }
-        }
-        // fallback: look for direct identifier
-        const name = node.childForFieldName('name');
-        return name?.text;
+        return extractDartFieldNames(node)[0];
+    },
+    extractNames(node) {
+        return extractDartFieldNames(node);
     },
     extractType(node) {
-        // declaration > type_identifier (first named child usually)
+        // declaration > type_identifier (the type annotation, present for both the
+        // instance-field shape and `static final String b = …`). `static const a = 1;`
+        // has no annotation → undefined (untyped).
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child && (child.type === 'type_identifier' || child.type === 'function_type')) {
@@ -48,28 +75,22 @@ export const dartConfig = {
         }
         return undefined;
     },
+    // Per-name: Dart convention is underscore-prefixed = private. A single
+    // declaration can mix visibilities (`static const _p = 1, q = 2;`), so the
+    // decision is keyed on the individual field name.
+    extractVisibilityForName(_node, name) {
+        return name.startsWith('_') ? 'private' : 'public';
+    },
     extractVisibility(node) {
-        // Dart uses _ prefix for private
-        // Walk to find the identifier name
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'initialized_identifier_list') {
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const init = child.namedChild(j);
-                    if (init?.type === 'initialized_identifier') {
-                        const ident = init.firstNamedChild;
-                        if (ident?.text?.startsWith('_'))
-                            return 'private';
-                    }
-                }
-            }
-        }
-        return 'public';
+        const first = extractDartFieldNames(node)[0];
+        return first?.startsWith('_') ? 'private' : 'public';
     },
     isStatic(node) {
         return hasKeyword(node, 'static');
     },
     isReadonly(node) {
+        // `final` / `const` (both `final_builtin`/`const_builtin` nodes whose text
+        // is `final`/`const`) are read-only.
         return hasKeyword(node, 'final') || hasKeyword(node, 'const');
     },
 };

package/dist/core/ingestion/field-extractors/configs/jvm.js

@@ -60,12 +60,49 @@ export const javaConfig = {
 // Kotlin
 // ---------------------------------------------------------------------------
 const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+/** A property_declaration is a companion-object member when its nearest
+ *  class-body ancestor is the body of a companion_object (F52, issue #1919).
+ *  Companion members are addressed statically through the enclosing class
+ *  (`C.TAG`), so they are marked static. */
+function isInsideKotlinCompanion(node) {
+    for (let cur = node.parent; cur !== null; cur = cur.parent) {
+        if (cur.type === 'class_body')
+            return cur.parent?.type === 'companion_object';
+        if (cur.type === 'companion_object')
+            return true;
+    }
+    return false;
+}
 export const kotlinConfig = {
     language: SupportedLanguages.Kotlin,
-    typeDeclarationNodes: ['class_declaration', 'object_declaration'],
+    // F52: include companion_object so a companion property's innermost
+    // class-container owner (findEnclosingClassNode returns the companion_object)
+    // is recognized as a type declaration and its nested class_body is walked.
+    // The structure query already creates the Property node and owns it on the
+    // ENCLOSING class for anonymous companions / on the named companion Class —
+    // this entry only drives field-metadata enrichment, so it does NOT change
+    // ownership or emit a second node (no double-count).
+    typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
     fieldNodeTypes: ['property_declaration'],
     bodyNodeTypes: ['class_body'],
     defaultVisibility: 'public',
+    // F52: an anonymous `companion object { ... }` has no name child, so the
+    // generic factory's `childForFieldName('name')` owner lookup is empty and
+    // `extract()` would bail before walking the body. Supply a stable owner
+    // name (the named companion's identifier, else "Companion") so the body IS
+    // walked; the resulting FieldInfo map is keyed by field NAME only, so the
+    // owner name does not affect which Property node gets enriched.
+    extractOwnerName(node) {
+        const typeIdentifierText = node.namedChildren.find((c) => c.type === 'type_identifier')?.text;
+        if (node.type === 'companion_object') {
+            // Anonymous companions have no type_identifier — fall back to "Companion".
+            return typeIdentifierText ?? 'Companion';
+        }
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        return typeIdentifierText;
+    },
     extractName(node) {
         // property_declaration > variable_declaration > simple_identifier
         for (let i = 0; i < node.namedChildCount; i++) {
@@ -107,9 +144,11 @@ export const kotlinConfig = {
     extractVisibility(node) {
         return findVisibility(node, KOTLIN_VIS, 'public', 'modifiers');
     },
-    isStatic(_node) {
-        // Kotlin doesn't have static; companion object members are handled separately
-        return false;
+    isStatic(node) {
+        // Kotlin has no `static`, but companion-object members are accessed
+        // statically through the enclosing class (`C.TAG`) — mark them static
+        // so the field metadata reflects that (F52).
+        return isInsideKotlinCompanion(node);
     },
     isReadonly(node) {
         // 'val' = readonly, 'var' = mutable

package/dist/core/ingestion/field-extractors/configs/swift.d.ts

@@ -2,7 +2,18 @@ import type { FieldExtractionConfig } from '../generic.js';
 /**
  * Swift field extraction config.
  *
- * Handles property_declaration inside class_body / protocol_body.
+ * Handles property_declaration inside class_body / protocol_body and
+ * protocol_property_declaration inside protocol_body (F75 — protocol property
+ * requirements like "var title: String { get }").
+ *
  * tree-sitter-swift uses property_declaration for stored/computed properties.
+ * A protocol property requirement parses to its own node type,
+ * protocol_property_declaration, whose name lives in a "name:" pattern field
+ * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its
+ * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a
+ * protocol_property_requirements child. Note: Swift reuses the "name:" field
+ * across many positions (func name, every parameter label, parameter/return
+ * type), so the name is synthesized from the simple_identifier inside the
+ * pattern rather than read blindly off "name:".
  */
 export declare const swiftConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/swift.js

@@ -1,6 +1,6 @@
 // gitnexus/src/core/ingestion/field-extractors/configs/swift.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { hasKeyword, findVisibility } from './helpers.js';
+import { hasKeyword, hasModifier, findVisibility } from './helpers.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 const SWIFT_VIS = new Set([
     'public',
@@ -12,17 +12,32 @@ const SWIFT_VIS = new Set([
 /**
  * Swift field extraction config.
  *
- * Handles property_declaration inside class_body / protocol_body.
+ * Handles property_declaration inside class_body / protocol_body and
+ * protocol_property_declaration inside protocol_body (F75 — protocol property
+ * requirements like "var title: String { get }").
+ *
  * tree-sitter-swift uses property_declaration for stored/computed properties.
+ * A protocol property requirement parses to its own node type,
+ * protocol_property_declaration, whose name lives in a "name:" pattern field
+ * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its
+ * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a
+ * protocol_property_requirements child. Note: Swift reuses the "name:" field
+ * across many positions (func name, every parameter label, parameter/return
+ * type), so the name is synthesized from the simple_identifier inside the
+ * pattern rather than read blindly off "name:".
  */
 export const swiftConfig = {
     language: SupportedLanguages.Swift,
     typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
-    fieldNodeTypes: ['property_declaration'],
+    fieldNodeTypes: ['property_declaration', 'protocol_property_declaration'],
     bodyNodeTypes: ['class_body', 'protocol_body'],
     defaultVisibility: 'internal',
     extractName(node) {
-        // property_declaration > pattern > simple_identifier
+        // property_declaration > pattern > simple_identifier, and
+        // protocol_property_declaration > name: (pattern ... simple_identifier).
+        // For protocol_property_declaration the pattern wraps a leading
+        // value_binding_pattern ("var") plus the simple_identifier — the loop
+        // below skips the binding keyword and returns the identifier.
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child?.type === 'pattern') {
@@ -56,7 +71,17 @@ export const swiftConfig = {
         return findVisibility(node, SWIFT_VIS, 'internal', 'modifiers');
     },
     isStatic(node) {
-        return hasKeyword(node, 'static') || hasKeyword(node, 'class');
+        // `static`/`class` (type-level) modifiers live inside a `modifiers`
+        // wrapper for both property_declaration and protocol_property_declaration
+        // (e.g. `static var shared: P { get }`), so check the wrapper too.
+        // `hasKeyword` compares each direct child by `.text` equality: it matches a
+        // single-modifier wrapper (`modifiers.text === 'static'`) but fails for a
+        // multi-modifier wrapper (`private static` → `modifiers.text === 'private static'`),
+        // which `hasModifier` handles by descending into the wrapper's children.
+        return (hasKeyword(node, 'static') ||
+            hasKeyword(node, 'class') ||
+            hasModifier(node, 'modifiers', 'static') ||
+            hasModifier(node, 'modifiers', 'class'));
     },
     isReadonly(node) {
         // 'let' = constant/readonly, 'var' = variable

package/dist/core/ingestion/filesystem-walker.d.ts

@@ -1,7 +1,3 @@
-export interface FileEntry {
-    path: string;
-    content: string;
-}
 /** Lightweight entry — path + size from stat, no content in memory */
 export interface ScannedFile {
     path: string;
@@ -21,8 +17,3 @@ export declare const walkRepositoryPaths: (repoPath: string, onProgress?: (curre
  * Returns a Map for O(1) lookup. Silently skips files that fail to read.
  */
 export declare const readFileContents: (repoPath: string, relativePaths: string[]) => Promise<Map<string, string>>;
-/**
- * Legacy API — scans and reads everything into memory.
- * Used by sequential fallback path only.
- */
-export declare const walkRepository: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<FileEntry[]>;

package/dist/core/ingestion/filesystem-walker.js

@@ -111,14 +111,3 @@ export const readFileContents = async (repoPath, relativePaths) => {
     }
     return contents;
 };
-/**
- * Legacy API — scans and reads everything into memory.
- * Used by sequential fallback path only.
- */
-export const walkRepository = async (repoPath, onProgress) => {
-    const scanned = await walkRepositoryPaths(repoPath, onProgress);
-    const contents = await readFileContents(repoPath, scanned.map((f) => f.path));
-    return scanned
-        .filter((f) => contents.has(f.path))
-        .map((f) => ({ path: f.path, content: contents.get(f.path) }));
-};

package/dist/core/ingestion/languages/c/import-decomposer.d.ts

@@ -4,5 +4,14 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C #include maps to a wildcard import (all symbols
  * from the header are visible).
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <stdio.h>   → system_lib_string
+ *   #include "local.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path). Emitting it as an import
+ * source produces a garbage literal edge, so we skip it entirely — matching
+ * the convention in interpretCImport, which drops imports with no resolvable
+ * source (issue #1919 F5).
  */
 export declare function splitCInclude(node: SyntaxNode): CaptureMatch | null;

package/dist/core/ingestion/languages/c/import-decomposer.js

@@ -3,10 +3,20 @@ import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C #include maps to a wildcard import (all symbols
  * from the header are visible).
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <stdio.h>   → system_lib_string
+ *   #include "local.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path). Emitting it as an import
+ * source produces a garbage literal edge, so we skip it entirely — matching
+ * the convention in interpretCImport, which drops imports with no resolvable
+ * source (issue #1919 F5).
  */
 export function splitCInclude(node) {
     // node.type === 'preproc_include'
     // path field: (string_literal (string_content)) | (system_lib_string)
+    //             | (identifier)  ← computed macro include, NOT a header path
     const pathNode = node.childForFieldName?.('path') ?? null;
     if (pathNode === null) {
         // Fallback: scan children
@@ -23,6 +33,11 @@ export function splitCInclude(node) {
     return buildIncludeCapture(node, pathNode);
 }
 function buildIncludeCapture(node, pathNode) {
+    // Skip computed includes (`#include MACRO`) — the path is an `identifier`,
+    // not a literal header path. Emitting it would create a garbage import.
+    if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') {
+        return null;
+    }
     let raw;
     if (pathNode.type === 'string_literal') {
         // string_literal has children: `"`, string_content, `"`

package/dist/core/ingestion/languages/cpp/import-decomposer.d.ts

@@ -4,6 +4,13 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C++ #include maps to a wildcard import (all symbols
  * from the header are visible). Identical to C's splitCInclude.
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <map>      → system_lib_string
+ *   #include "User.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path); we skip it so it never
+ * becomes a garbage literal import source (issue #1919 F5).
  */
 export declare function splitCppInclude(node: SyntaxNode): CaptureMatch | null;
 /**

package/dist/core/ingestion/languages/cpp/import-decomposer.js

@@ -3,6 +3,13 @@ import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C++ #include maps to a wildcard import (all symbols
  * from the header are visible). Identical to C's splitCInclude.
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <map>      → system_lib_string
+ *   #include "User.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path); we skip it so it never
+ * becomes a garbage literal import source (issue #1919 F5).
  */
 export function splitCppInclude(node) {
     const pathNode = node.childForFieldName?.('path') ?? null;
@@ -20,6 +27,11 @@ export function splitCppInclude(node) {
     return buildIncludeCapture(node, pathNode);
 }
 function buildIncludeCapture(node, pathNode) {
+    // Skip computed includes (`#include MACRO`) — the path is an `identifier`,
+    // not a literal header path. Emitting it would create a garbage import.
+    if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') {
+        return null;
+    }
     let raw;
     if (pathNode.type === 'string_literal') {
         const content = pathNode.namedChildren.find((c) => c.type === 'string_content');

package/dist/core/ingestion/languages/dart/query.js

@@ -37,6 +37,46 @@ const DART_SCOPE_QUERY = `
 (extension_declaration name: (identifier) @declaration.name) @declaration.class
 (enum_declaration name: (identifier) @declaration.name) @declaration.enum
 
+; ── Declarations — type aliases (old-style + new-style function typedefs) ────
+; Both forms parse as type_alias; the name position differs, and a generic
+; <T> parameter list intervenes for the generic variants. Per #1919 review CF2,
+; a generic type_parameters node sits between the name and the next anchor, so
+; the non-generic adjacency patterns silently drop the generic forms. Four
+; standalone patterns (NOT one alternation — the tree-sitter 0.21 hazard drops
+; sibling branches) keep the name capture unambiguous and single-match per form:
+;   non-generic old-style  typedef int Cmp(int a, int b);
+;       children: return-type, NAME, formal_parameter_list
+;   generic old-style      typedef int Cmp<T>(T a, T b);          (CF2)
+;       children: return-type, NAME, type_parameters, formal_parameter_list
+;   non-generic new-style  typedef Pred = bool Function(int);
+;       children: NAME, "=", function_type
+;   generic new-style      typedef Mapper<T> = T Function(T);
+;       children: NAME, type_parameters, "=", function_type
+; The alias name is the type_identifier immediately before the param list (old)
+; or before "=" (new); for the generic forms it is the one immediately before
+; the intervening type_parameters. Mirrors Kotlin's @declaration.type_alias
+; rule; the generic scope-extractor maps "type_alias" → TypeAlias.
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (formal_parameter_list)) @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (type_parameters)
+  .
+  (formal_parameter_list)) @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  "=") @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (type_parameters)
+  .
+  "=") @declaration.type_alias
+
 ; ── Declarations — top-level functions (parent is program, not method) ───────
 (program
   (function_signature