gitnexus 1.6.11-rc.2 → 1.6.11-rc.21

package/dist/core/incremental/derived-writeback.js

@@ -0,0 +1,68 @@
+/**
+ * Incremental derived-layer writeback helpers (#3016).
+ *
+ * The derived layers — Leiden communities, execution flows, and the FTS
+ * indexes — are graph-wide, so every analyze run rebuilt all three in full no
+ * matter how small the diff. A surgical incremental write can instead:
+ *   - drop and rebuild only the FTS indexes whose tables hold rows in the
+ *     write set (LadybugDB still cannot DML a table with a live FTS index —
+ *     #2589 — so a table being written must still lose its index first);
+ *   - leave the untouched tables' rows alone, so their indexes stay live;
+ *   - reuse persisted Community/Process rows only when the file-hash diff is
+ *     empty (no added, changed, or deleted files). Any content change can
+ *     add, rename, or retarget symbols that Leiden and flow extraction
+ *     consume — a no-deletion edit is not a validity proof.
+ */
+import { FTS_INDEXES } from '../search/fts-schema.js';
+const FTS_TABLE_NAMES = new Set(FTS_INDEXES.map((i) => i.table));
+/** The FTS-backed members of `tables`. */
+export const ftsTablesAmong = (tables) => {
+    const out = new Set();
+    for (const table of tables) {
+        if (FTS_TABLE_NAMES.has(table))
+            out.add(table);
+    }
+    return out;
+};
+/**
+ * Whether a surgical incremental write may reuse the persisted derived layer.
+ *
+ * Deletions disqualify it: the persisted Community/Process rows and their
+ * MEMBER_OF / STEP_IN_PROCESS edges can reference nodes that no longer exist
+ * after this run, and nothing short of re-deriving can tell which.
+ *
+ * Added or content-changed files also disqualify it: they can introduce,
+ * rename, or retarget symbols and CALLS edges that Leiden and flow extraction
+ * consume. File-deletion-only was too weak a proof that the derived graph is
+ * still valid.
+ */
+export const shouldPreservePersistedDerivedGraph = (diff) => diff.deleted.length === 0 && diff.added.length === 0 && diff.changed.length === 0;
+/**
+ * FTS-backed node tables that the fresh graph will WRITE rows into for
+ * `fileSet` — the inserting half of the DML.
+ *
+ * Callers must union this with a DB probe for the deleting half
+ * (`nodeTablesWithRowsForFiles`): a table whose last row in these files was
+ * just removed by the edit has nothing here, but still holds a stale row that
+ * the writeback must delete, and deleting it means taking its index down too.
+ */
+export const incrementalFtsTablesFromGraph = (graph, fileSet) => {
+    const touched = new Set();
+    graph.forEachNode((n) => {
+        const filePath = n.properties?.filePath;
+        if (!filePath || !fileSet.has(filePath))
+            return;
+        if (FTS_TABLE_NAMES.has(n.label))
+            touched.add(n.label);
+    });
+    return touched;
+};
+/**
+ * The node tables an incremental DETACH DELETE should target, given the FTS
+ * tables this run is rebuilding.
+ *
+ * Every non-FTS table (Folder, CodeElement, …) deletes as before. An FTS-backed
+ * table only deletes when its index is being rebuilt anyway, because deleting
+ * from it otherwise would mean DML against a live FTS index (#2589).
+ */
+export const nodeTablesForIncrementalDelete = (allNodeTables, rebuildingFtsTables) => allNodeTables.filter((tableName) => !FTS_TABLE_NAMES.has(tableName) || rebuildingFtsTables.has(tableName));

package/dist/core/incremental/subgraph-extract.d.ts

@@ -6,9 +6,9 @@
  * replaced, produce a smaller KnowledgeGraph that contains:
  *
  *   - Every node whose `properties.filePath` is in `toWriteSet`.
- *   - Every graph-wide node (Community, Process, and Spring metadata
- *     placeholders) — these are regenerated each run and must be fully
- *     rewritten.
+ *   - Graph-wide Community/Process nodes unless `includeDerivedGraphWide`
+ *     is false (#3016 incremental preserve). Spring metadata placeholders
+ *     are always included.
  *   - Every relationship where AT LEAST ONE endpoint is in the writable
  *     set above. Relationships entirely between unchanged-file nodes
  *     are skipped — their rows are still in the DB and re-inserting
@@ -48,7 +48,9 @@
  * IMPORTS from the pre-pipeline DB) covers that case instead.
  */
 import type { KnowledgeGraph } from '../graph/types.js';
-export declare const extractChangedSubgraph: (fullGraph: KnowledgeGraph, toWriteSet: ReadonlySet<string>) => KnowledgeGraph;
+export declare const extractChangedSubgraph: (fullGraph: KnowledgeGraph, toWriteSet: ReadonlySet<string>, options?: {
+    includeDerivedGraphWide?: boolean;
+}) => KnowledgeGraph;
 /**
  * Public — derive the EFFECTIVE write-set: `toWriteSet` expanded by one
  * hop along every file-owned edge in the new graph that crosses the

package/dist/core/incremental/subgraph-extract.js

@@ -6,9 +6,9 @@
  * replaced, produce a smaller KnowledgeGraph that contains:
  *
  *   - Every node whose `properties.filePath` is in `toWriteSet`.
- *   - Every graph-wide node (Community, Process, and Spring metadata
- *     placeholders) — these are regenerated each run and must be fully
- *     rewritten.
+ *   - Graph-wide Community/Process nodes unless `includeDerivedGraphWide`
+ *     is false (#3016 incremental preserve). Spring metadata placeholders
+ *     are always included.
  *   - Every relationship where AT LEAST ONE endpoint is in the writable
  *     set above. Relationships entirely between unchanged-file nodes
  *     are skipped — their rows are still in the DB and re-inserting
@@ -108,12 +108,14 @@ const indexNodeFilePaths = (fullGraph) => {
     });
     return idx;
 };
-export const extractChangedSubgraph = (fullGraph, toWriteSet) => {
+export const extractChangedSubgraph = (fullGraph, toWriteSet, options) => {
     const sub = createKnowledgeGraph();
     const writableNodeIds = new Set();
+    const includeDerivedGraphWide = options?.includeDerivedGraphWide !== false;
     fullGraph.forEachNode((n) => {
         const filePath = n.properties?.filePath;
-        const include = (filePath && toWriteSet.has(filePath)) || isGraphWideNode(n);
+        const derivedWide = includeDerivedGraphWide || (n.label !== 'Community' && n.label !== 'Process');
+        const include = (filePath && toWriteSet.has(filePath)) || (isGraphWideNode(n) && derivedWide);
         if (include) {
             sub.addNode(n);
             writableNodeIds.add(n.id);

package/dist/core/index-content-drift.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Does the index still reflect the files it actually covers?
+ *
+ * `status` used to answer this with a repo-wide `git status --porcelain`
+ * boolean, which says something different: whether the working tree differs
+ * from HEAD. Those two questions diverge in both directions. A scratch file,
+ * a build artifact, or a tracked file under a tool directory the indexer
+ * never reads makes the tree dirty while every indexed file is byte-current —
+ * and because `analyze` cannot commit or delete that file, the resulting
+ * "stale (re-run gitnexus analyze)" verdict was unclearable (#3077). It also
+ * misses the reverse case: reverting a file that was indexed while dirty
+ * leaves a clean tree over an index holding the pre-revert content.
+ *
+ * `meta.fileHashes` already records the exact set of files the last run
+ * covered, so the question can be answered directly. This module recomputes
+ * the coverage set with the same `walkRepositoryPaths` scan (ignore rules and
+ * dotfile handling stay shared) and the large-file cap recorded in
+ * `meta.indexCoverage`, hashes only the paths that can actually have changed
+ * since that run, and diffs against what was recorded.
+ */
+import type { RepoMeta } from '../storage/repo-meta.js';
+/** Why the recorded coverage set could not be compared against disk at all. */
+export type IndexContentUnmeasurableReason = 
+/** Metadata predates per-file hashes, or the run recorded none (non-git). */
+'no-file-hashes'
+/** The repository scan or hashing pass threw. */
+ | 'scan-failed';
+/**
+ * A three-way verdict. `'unmeasurable'` is kept apart from `'current'` on
+ * purpose: it means the comparison never ran, which is not evidence the index
+ * is fresh. Legacy metadata without hashes still falls back to the working-tree
+ * check; a failed scan must not.
+ */
+export type IndexContentDrift = {
+    kind: 'current';
+    coveredFileCount: number;
+} | {
+    kind: 'drifted';
+    changed: string[];
+    added: string[];
+    deleted: string[];
+} | {
+    kind: 'unmeasurable';
+    reason: IndexContentUnmeasurableReason;
+};
+export type IndexCoveragePolicy = NonNullable<RepoMeta['indexCoverage']>;
+/**
+ * Compare the files recorded in `fileHashes` against the current working tree.
+ *
+ * `added` covers files the index would pick up but has never seen, so a new
+ * source file still reports stale — the index is genuinely incomplete then,
+ * and comparing only the recorded entries would wave that through.
+ */
+export declare const detectIndexContentDrift: (repoPath: string, fileHashes: Readonly<Record<string, string>> | undefined, coverage?: IndexCoveragePolicy) => Promise<IndexContentDrift>;

package/dist/core/index-content-drift.js

@@ -0,0 +1,127 @@
+/**
+ * Does the index still reflect the files it actually covers?
+ *
+ * `status` used to answer this with a repo-wide `git status --porcelain`
+ * boolean, which says something different: whether the working tree differs
+ * from HEAD. Those two questions diverge in both directions. A scratch file,
+ * a build artifact, or a tracked file under a tool directory the indexer
+ * never reads makes the tree dirty while every indexed file is byte-current —
+ * and because `analyze` cannot commit or delete that file, the resulting
+ * "stale (re-run gitnexus analyze)" verdict was unclearable (#3077). It also
+ * misses the reverse case: reverting a file that was indexed while dirty
+ * leaves a clean tree over an index holding the pre-revert content.
+ *
+ * `meta.fileHashes` already records the exact set of files the last run
+ * covered, so the question can be answered directly. This module recomputes
+ * the coverage set with the same `walkRepositoryPaths` scan (ignore rules and
+ * dotfile handling stay shared) and the large-file cap recorded in
+ * `meta.indexCoverage`, hashes only the paths that can actually have changed
+ * since that run, and diffs against what was recorded.
+ */
+import { constants as fsConstants } from 'node:fs';
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { walkRepositoryPaths } from './ingestion/filesystem-walker.js';
+import { computeFileHashesDetailed } from '../storage/file-hash.js';
+import { listWorkingTreeDirtyPaths } from '../storage/git.js';
+import { isGitNexusManagedPath } from '../storage/gitnexus-managed-paths.js';
+import { chunk } from '../lib/utils.js';
+import { logger } from './logger.js';
+const HASH_BATCH = 100;
+const collectUnreadablePaths = async (repoPath, relPaths) => {
+    const unreadable = [];
+    for (const batch of chunk(relPaths, HASH_BATCH)) {
+        await Promise.all(batch.map(async (rel) => {
+            try {
+                await access(path.join(repoPath, rel), fsConstants.R_OK);
+            }
+            catch {
+                unreadable.push(rel);
+            }
+        }));
+    }
+    unreadable.sort();
+    return unreadable;
+};
+/**
+ * Compare the files recorded in `fileHashes` against the current working tree.
+ *
+ * `added` covers files the index would pick up but has never seen, so a new
+ * source file still reports stale — the index is genuinely incomplete then,
+ * and comparing only the recorded entries would wave that through.
+ */
+export const detectIndexContentDrift = async (repoPath, fileHashes, coverage) => {
+    if (!fileHashes || Object.keys(fileHashes).length === 0) {
+        return { kind: 'unmeasurable', reason: 'no-file-hashes' };
+    }
+    // Excluded from BOTH sides, or GitNexus's own output guarantees a mismatch:
+    // analyze rewrites AGENTS.md/CLAUDE.md after recording hashes, so they read
+    // as `added` on a first run and `changed` on every run after that — a fresh
+    // index would report itself stale forever.
+    const recorded = Object.fromEntries(Object.entries(fileHashes).filter(([rel]) => !isGitNexusManagedPath(rel)));
+    if (Object.keys(recorded).length === 0) {
+        return { kind: 'unmeasurable', reason: 'no-file-hashes' };
+    }
+    try {
+        const scanned = await walkRepositoryPaths(repoPath, undefined, {
+            quiet: true,
+            maxFileSizeBytes: coverage?.maxFileSizeBytes,
+        });
+        const scannedPaths = scanned.map((file) => file.path).filter((p) => !isGitNexusManagedPath(p));
+        const scannedSet = new Set(scannedPaths);
+        const recordedSet = new Set(Object.keys(recorded));
+        // Legacy indexes have `fileHashes` but no `indexCoverage`. A later default
+        // cap would omit a still-present hashed file and call it deleted. Recorded
+        // paths that still exist stay in the coverage set even if this walk skipped
+        // them for size.
+        const recovered = new Set();
+        for (const rel of recordedSet) {
+            if (scannedSet.has(rel))
+                continue;
+            try {
+                await access(path.join(repoPath, rel), fsConstants.R_OK);
+                recovered.add(rel);
+                scannedSet.add(rel);
+            }
+            catch {
+                // Missing or unreadable: stays deleted / changed below.
+            }
+        }
+        const added = scannedPaths.filter((p) => !recordedSet.has(p)).sort();
+        const deleted = [...recordedSet].filter((p) => !scannedSet.has(p)).sort();
+        const intersection = [...recordedSet].filter((p) => scannedSet.has(p));
+        const dirtyNow = listWorkingTreeDirtyPaths(repoPath);
+        const dirtyAtIndex = coverage?.dirtyPaths;
+        const dirtyNowSet = dirtyNow === null ? null : new Set(dirtyNow);
+        const dirtyAtIndexSet = dirtyAtIndex === undefined ? undefined : new Set(dirtyAtIndex);
+        const hashCandidates = dirtyNowSet === null || dirtyAtIndexSet === undefined
+            ? intersection
+            : intersection.filter((p) => dirtyAtIndexSet.has(p) || dirtyNowSet.has(p) || recovered.has(p));
+        const hashCandidateSet = new Set(hashCandidates);
+        const skipHash = intersection.filter((p) => !hashCandidateSet.has(p));
+        const unreadableFromAccess = await collectUnreadablePaths(repoPath, skipHash);
+        const unreadableSet = new Set(unreadableFromAccess);
+        const { hashes: hashed, unreadable: unreadableFromHash } = await computeFileHashesDetailed(repoPath, hashCandidates);
+        for (const p of unreadableFromHash)
+            unreadableSet.add(p);
+        const changed = [];
+        for (const p of intersection) {
+            if (unreadableSet.has(p)) {
+                changed.push(p);
+                continue;
+            }
+            const currentHash = hashed.get(p) ?? recorded[p];
+            if (currentHash !== recorded[p])
+                changed.push(p);
+        }
+        changed.sort();
+        if (changed.length === 0 && added.length === 0 && deleted.length === 0) {
+            return { kind: 'current', coveredFileCount: scannedSet.size };
+        }
+        return { kind: 'drifted', changed, added, deleted };
+    }
+    catch (err) {
+        logger.warn({ err, repoPath }, 'index content drift scan failed');
+        return { kind: 'unmeasurable', reason: 'scan-failed' };
+    }
+};

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

@@ -7,11 +7,21 @@ export interface ScannedFile {
 export interface FilePath {
     path: string;
 }
-/**
- * Phase 1: Scan repository — stat files to get paths + sizes, no content loaded.
- * Memory: ~10MB for 100K files vs ~1GB+ with content.
- */
-export declare const walkRepositoryPaths: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<ScannedFile[]>;
+export interface WalkRepositoryOptions {
+    /**
+     * Suppress the operator-facing large-file notice. Set by read-only callers
+     * such as `status`, which reuse this scan purely to learn which files the
+     * index covers and must not emit analyze's progress commentary.
+     */
+    quiet?: boolean;
+    /**
+     * Override the large-file cap. `status` replays the bytes recorded at
+     * analyze time so `--max-file-size` / `GITNEXUS_MAX_FILE_SIZE` cannot
+     * silently drop a file that the index actually covers.
+     */
+    maxFileSizeBytes?: number;
+}
+export declare const walkRepositoryPaths: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void, options?: WalkRepositoryOptions) => Promise<ScannedFile[]>;
 /**
  * Phase 2: Read file contents for a specific set of relative paths.
  * Returns a Map for O(1) lookup. Silently skips files that fail to read.

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

@@ -39,9 +39,26 @@ const warnLargeFileSkip = (message) => {
  * Phase 1: Scan repository — stat files to get paths + sizes, no content loaded.
  * Memory: ~10MB for 100K files vs ~1GB+ with content.
  */
-export const walkRepositoryPaths = async (repoPath, onProgress) => {
+const assertWalkRootIsDirectory = async (repoPath) => {
+    let st;
+    try {
+        st = await fs.stat(repoPath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR') {
+            throw new Error(`walkRepositoryPaths: path does not exist: ${repoPath}`);
+        }
+        throw err;
+    }
+    if (!st.isDirectory()) {
+        throw new Error(`walkRepositoryPaths: not a directory: ${repoPath}`);
+    }
+};
+export const walkRepositoryPaths = async (repoPath, onProgress, options = {}) => {
+    await assertWalkRootIsDirectory(repoPath);
     const ignoreFilter = await createIgnoreFilter(repoPath);
-    const maxFileSizeBytes = getMaxFileSizeBytes();
+    const maxFileSizeBytes = options.maxFileSizeBytes ?? getMaxFileSizeBytes();
     const filtered = await glob('**/*', {
         cwd: repoPath,
         nodir: true,
@@ -81,7 +98,7 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
     // scans. Canonicalize once at the scan boundary so every downstream phase sees
     // the same repository order.
     deduplicatedEntries.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
-    if (skippedLarge > 0) {
+    if (skippedLarge > 0 && !options.quiet) {
         const isDefault = maxFileSizeBytes === DEFAULT_MAX_FILE_SIZE_BYTES;
         const isOverrideUnset = !process.env.GITNEXUS_MAX_FILE_SIZE;
         const suffix = isDefault ? ', likely generated/vendored' : '';

package/dist/core/ingestion/frameworks/spring/dynamic-lookups.d.ts

@@ -0,0 +1,22 @@
+import type { ParsedFile, Range, ScopeId } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { DiInjectionMatch } from '../../di-extractors/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+export interface SpringDynamicLookupFact {
+    readonly ownerScopeId: ScopeId;
+    readonly ownerRange: Range;
+    readonly receiverName: string;
+    readonly methodName: string;
+    readonly targetTypeName: string;
+}
+export declare function springDynamicLookupCardinality(receiverName: string, methodName: string): DiInjectionMatch['cardinality'] | null;
+export interface SpringDynamicLookupMetadataAdapter {
+    getFacts(filePath: string): readonly SpringDynamicLookupFact[];
+}
+/**
+ * Attach AST-captured programmatic Spring lookups to the framework-neutral DI
+ * resolver. Java/Kotlin own syntax capture; this shared JVM/Spring seam owns
+ * import-aware type binding and metadata attachment.
+ */
+export declare function createSpringDynamicLookupMetadataAttacher(adapter: SpringDynamicLookupMetadataAdapter): (graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes) => void;

package/dist/core/ingestion/frameworks/spring/dynamic-lookups.js

@@ -0,0 +1,124 @@
+import { SPRING_DI_INJECTION_SITES_PROPERTY } from '../../di-extractors/spring.js';
+import { resolveCallerGraphId, resolveDefGraphId, } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
+const COLLECTION_LOOKUP_METHODS = new Set(['getBeans', 'getBeansOfType']);
+const SINGLE_LOOKUP_METHODS = new Set(['getBean']);
+/**
+ * Distinctive utility names plus conventional Spring context variable names.
+ * Generic locals remain recall-oriented because repositories often omit the
+ * third-party context type from the index; AST call/class-literal gates and
+ * import-aware target resolution prevent the raw-text false-positive class.
+ */
+const KNOWN_RECEIVERS = new Set([
+    'SpringContextUtil',
+    'SpringContextHolder',
+    'SpringBeanUtil',
+    'ApplicationContextProvider',
+    'BeanFactoryProvider',
+    'ApplicationContext',
+    'BeanFactory',
+    'ListableBeanFactory',
+    'applicationContext',
+    'context',
+    'ctx',
+    'appContext',
+    'beanFactory',
+]);
+export function springDynamicLookupCardinality(receiverName, methodName) {
+    const receiverSimpleName = receiverName.slice(receiverName.lastIndexOf('.') + 1);
+    if (!KNOWN_RECEIVERS.has(receiverSimpleName))
+        return null;
+    if (COLLECTION_LOOKUP_METHODS.has(methodName))
+        return 'collection';
+    if (SINGLE_LOOKUP_METHODS.has(methodName))
+        return 'single';
+    return null;
+}
+function visibleTypeDefinitions(fact, indexes) {
+    const simpleName = fact.targetTypeName.slice(fact.targetTypeName.lastIndexOf('.') + 1);
+    let scopeId = fact.ownerScopeId;
+    while (scopeId !== null) {
+        const visible = lookupBindingsAt(scopeId, simpleName, indexes)
+            .map(({ def }) => def)
+            .filter((def) => isClassLike(def.type))
+            .filter((def) => !fact.targetTypeName.includes('.') || def.qualifiedName === fact.targetTypeName);
+        if (visible.length > 0) {
+            const unique = new Map(visible.map((def) => [def.nodeId, def]));
+            return [...unique.values()];
+        }
+        scopeId = indexes.scopeTree.getScope(scopeId)?.parent ?? null;
+    }
+    return [];
+}
+function resolveTargetTypeName(graph, fact, callerLanguage, nodeLookup, indexes) {
+    const graphIds = new Set();
+    for (const definition of visibleTypeDefinitions(fact, indexes)) {
+        const graphId = resolveDefGraphId(definition.filePath, definition, nodeLookup);
+        if (graphId === undefined)
+            continue;
+        const node = graph.getNode(graphId);
+        if ((node?.label === 'Class' ||
+            node?.label === 'Interface' ||
+            node?.label === 'Record' ||
+            node?.label === 'Enum') &&
+            node.properties.language === callerLanguage) {
+            graphIds.add(graphId);
+        }
+    }
+    if (graphIds.size !== 1)
+        return undefined;
+    const targetId = graphIds.values().next().value;
+    if (targetId === undefined)
+        return undefined;
+    const target = graph.getNode(targetId);
+    if (target === undefined)
+        return undefined;
+    const qualifiedName = target.properties.qualifiedName;
+    return typeof qualifiedName === 'string' ? qualifiedName : target.properties.name;
+}
+/**
+ * Attach AST-captured programmatic Spring lookups to the framework-neutral DI
+ * resolver. Java/Kotlin own syntax capture; this shared JVM/Spring seam owns
+ * import-aware type binding and metadata attachment.
+ */
+export function createSpringDynamicLookupMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        for (const parsed of parsedFiles) {
+            for (const fact of adapter.getFacts(parsed.filePath)) {
+                const cardinality = springDynamicLookupCardinality(fact.receiverName, fact.methodName);
+                if (cardinality === null)
+                    continue;
+                const callerId = resolveCallerGraphId(fact.ownerScopeId, indexes, nodeLookup, {
+                    startLine: fact.ownerRange.startLine,
+                    startCol: fact.ownerRange.startCol,
+                });
+                if (callerId === undefined)
+                    continue;
+                const caller = graph.getNode(callerId);
+                if (caller === undefined ||
+                    (caller.label !== 'Function' &&
+                        caller.label !== 'Method' &&
+                        caller.label !== 'Constructor')) {
+                    continue;
+                }
+                const targetTypeName = resolveTargetTypeName(graph, fact, caller.properties.language, nodeLookup, indexes);
+                if (targetTypeName === undefined)
+                    continue;
+                const match = {
+                    targetTypeName,
+                    cardinality,
+                    edgeSource: 'site',
+                    reason: `Spring dynamic lookup: ${fact.receiverName}.${fact.methodName}(${fact.targetTypeName})`,
+                };
+                // Singular lookups intentionally use the shared DI selection policy:
+                // a unique/@Primary candidate wins; unresolved multiplicity is an
+                // explicit 0.5-confidence fan-out rather than a guessed runtime winner.
+                const existing = caller.properties[SPRING_DI_INJECTION_SITES_PROPERTY];
+                caller.properties[SPRING_DI_INJECTION_SITES_PROPERTY] = [
+                    ...(Array.isArray(existing) ? existing : []),
+                    match,
+                ];
+            }
+        }
+    };
+}

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

@@ -297,6 +297,49 @@ interface LanguageProviderConfig {
      * Default: undefined (no interface-inheritance route resolution).
      */
     readonly extractRouteInheritanceTypes?: (tree: Parser.Tree, filePath: string) => SharedSpringType[];
+    /**
+     * Optional post-capture emission of synthetic structure members (nodes,
+     * symbols, ownership edges) that have no AST method node — e.g. Lombok
+     * accessors. Called once per file after the capture loop, at the same
+     * post-capture site as {@link extractDecoratorRoutes}.
+     *
+     * `classOwnersByNodeId` maps in-memory tree-sitter node ids of type
+     * declarations materialized in THIS file's capture loop to their graph
+     * node ids. Keys are never persisted; they exist only for the duration
+     * of the worker pass.
+     *
+     * Default: undefined (no synthetic structure members).
+     */
+    readonly synthesizeStructureMembers?: (tree: Parser.Tree, filePath: string, classOwnersByNodeId: ReadonlyMap<number, string>) => {
+        nodes: ReadonlyArray<{
+            id: string;
+            label: string;
+            properties: Record<string, unknown>;
+        }>;
+        symbols: ReadonlyArray<{
+            filePath: string;
+            name: string;
+            nodeId: string;
+            type: string;
+            ownerId?: string;
+            parameterCount?: number;
+            requiredParameterCount?: number;
+            parameterTypes?: string[];
+            returnType?: string;
+            visibility?: string;
+            isStatic?: boolean;
+            isAbstract?: boolean;
+            isFinal?: boolean;
+        }>;
+        relationships: ReadonlyArray<{
+            id: string;
+            sourceId: string;
+            targetId: string;
+            type: string;
+            confidence: number;
+            reason: string;
+        }>;
+    };
     /**
      * Harvest this file's module-level string constants (#2391 core, #2980 Java
      * parity) into the language-agnostic {@link ModuleConstants} shape, so the

package/dist/core/ingestion/languages/csharp/razor-view-components.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ASP.NET Core ViewComponent convention support.
+ *
+ * Same bound as Spring Boot DI in Java/Kotlin: do not resolve into the SDK
+ * (`Microsoft.AspNetCore.Mvc.ViewComponent`, `IViewComponentHelper`,
+ * `Component.InvokeAsync` itself). Those types live outside the workspace.
+ * The only hop worth taking is the framework convention that lands on an
+ * **in-repo** class — `InvokeAsync("Foo")` → workspace `FooViewComponent`,
+ * just as a Spring `@Autowired IFoo` fans out to an in-repo `@Service`,
+ * not to `ApplicationContext`.
+ *
+ * Razor templates are not parsed as C# (markup + code would poison
+ * tree-sitter-c-sharp). A small Razor state machine extracts C# islands and
+ * markup tag helpers; C# files use a string/comment-aware lexer so attributes
+ * and literals are not mistaken for helper calls. Literal names are enough
+ * because the target catalog is already built from parsed `.cs` classes.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+export interface RazorViewComponentConfig {
+    /** Repo-relative `.cshtml` path → extracted invocation names. */
+    readonly views: ReadonlyMap<string, readonly string[]>;
+}
+export interface ViewComponentAliasBind {
+    readonly className: string;
+    /** 1-based line of the type declaration (including leading attributes). */
+    readonly startLine: number;
+    /** 0-based column of the type declaration (including leading attributes). */
+    readonly startCol: number;
+    readonly aliases: readonly string[];
+}
+/** In-repo C# `Component.InvokeAsync("X")` / `ViewComponent("X")` literals. */
+export declare function extractCsharpViewComponentInvocations(source: string): string[];
+/**
+ * Explicit `[ViewComponent(Name = "...")]` aliases keyed to the following
+ * class declaration. Positional constructor arguments are ignored: the MVC
+ * attribute only exposes `Name` as a property.
+ */
+export declare function extractViewComponentAliasBinds(source: string): ViewComponentAliasBind[];
+/** Extract explicit `[ViewComponent(Name = "...")]` aliases by class name. */
+export declare function extractViewComponentAliases(source: string): ReadonlyMap<string, readonly string[]>;
+/** Extract statically resolvable ViewComponent names from one Razor template. */
+export declare function extractRazorViewComponentInvocations(source: string): string[];
+/**
+ * Read Razor views once per C# resolution pass. The same ignore rules and file
+ * size ceiling as repository scanning are applied, and edge emission later
+ * additionally requires a live File node. This prevents ignored, oversized,
+ * or concurrently removed templates from entering the graph.
+ */
+export declare function loadRazorViewComponentConfig(repoRoot: string): Promise<RazorViewComponentConfig>;
+/**
+ * Emit workspace File → in-repo ViewComponent Class CALLS edges.
+ *
+ * Targets are only Class nodes produced from this repo's `.cs` files. There is
+ * no lookup of ASP.NET SDK types; `: ViewComponent` in source is a naming
+ * hint, not a resolved EXTENDS edge to `Microsoft.AspNetCore.Mvc.ViewComponent`.
+ *
+ * Ambiguous component names fail closed: two in-repo classes claiming the
+ * same name is not evidence for picking either one.
+ */
+export declare function emitRazorViewComponentEdges(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, config: RazorViewComponentConfig | undefined, csharpSources: ReadonlyMap<string, string>): void;