gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/ingestion/languages/rust/interpret.js

@@ -1,6 +1,22 @@
 const REF_PREFIX_RE = /^&\s*(mut\s+)?/;
 const PTR_PREFIX_RE = /^\*\s*(const|mut)?\s*/;
+const DYN_PREFIX_RE = /^dyn\s+/;
 const ENUM_VARIANT_NAMES = new Set(['Some', 'None', 'Ok', 'Err']);
+// `dyn Trait`, `&dyn Trait`, `Box<dyn Trait>` all name a trait object whose
+// receiver-dispatch target is the trait itself (#2604) — strip the `dyn`
+// keyword and any auto-trait/lifetime bound list (`dyn Trait + Send`) down to
+// the principal trait name. Reference/pointer sigils are stripped by the
+// caller first; wrapper unwrapping (Box<T> etc.) runs before this so the
+// unwrapped inner text still gets the same treatment.
+function stripDynBound(t) {
+    if (!DYN_PREFIX_RE.test(t))
+        return t;
+    t = t.replace(DYN_PREFIX_RE, '');
+    const plus = t.indexOf('+');
+    if (plus !== -1)
+        t = t.slice(0, plus);
+    return t.trim();
+}
 // ─── interpretImport ──────────────────────────────────────────────────────
 export function interpretRustImport(captures) {
     const kind = captures['@import.kind']?.text;
@@ -104,6 +120,7 @@ export function normalizeRustTypeName(text) {
         if (inner !== null)
             t = inner;
     }
+    t = stripDynBound(t);
     const bracket = t.indexOf('<');
     if (bracket !== -1)
         t = t.slice(0, bracket);
@@ -168,6 +185,7 @@ function normalizeRustReturnType(text) {
             }
         }
     }
+    t = stripDynBound(t);
     const bracket = t.indexOf('<');
     if (bracket !== -1)
         t = t.slice(0, bracket);

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

@@ -9,6 +9,7 @@ const RUST_SCOPE_QUERY = `
 (enum_item) @scope.class
 (union_item) @scope.class
 (function_item) @scope.function
+(function_signature_item) @scope.function
 (closure_expression) @scope.function
 (block) @scope.block
 (if_expression) @scope.block
@@ -54,6 +55,14 @@ const RUST_SCOPE_QUERY = `
 (function_item
   name: (identifier) @declaration.name) @declaration.function
 
+;; Declarations — trait method signature (required method, no body,
+;; e.g. fn foo(self) -> T; inside a trait body). Without this, an abstract
+;; trait method is invisible to scope resolution — never owned by its
+;; trait's Class scope, so a dyn Trait receiver can never dispatch to
+;; it (#2604).
+(function_signature_item
+  name: (identifier) @declaration.name) @declaration.function
+
 ;; Declarations — struct fields
 (field_declaration
   name: (field_identifier) @declaration.name

package/dist/core/ingestion/languages/rust/range-binding.js

@@ -75,6 +75,12 @@ export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
                 }
             }
         }
+        // Publish per-type member bindings for the whole workspace before resolving
+        // assignments. Otherwise an importer processed before its defining file can
+        // miss a field or identity-method type solely because of file order.
+        const scopeMap = new Map(parsed.scopes.map((scope) => [scope.id, scope]));
+        processFieldTypeBindings(tree.rootNode, parsed, scopeMap);
+        processIdentityMethodBindings(parsed);
     }
     for (const parsed of parsedFiles) {
         const sourceText = ctx.fileContents.get(parsed.filePath);
@@ -103,8 +109,6 @@ export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
-        processFieldTypeBindings(tree.rootNode, parsed, scopeMap);
-        processIdentityMethodBindings(parsed);
         processForLoops(tree.rootNode, parsed, scopeMap, moduleScope, allReturnTypes);
         processPatternBindings(tree.rootNode, parsed, scopeMap, moduleScope);
         processStructDestructuring(tree.rootNode, parsed, scopeMap, moduleScope, allFieldTypes);

package/dist/core/ingestion/languages/swift/captures.js

@@ -41,8 +41,19 @@ import { getSwiftParser, getSwiftScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
+const SWIFT_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_declaration', 'lambda_literal']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['value_arguments']),
+    parameterNodeTypes: new Set(['parameter']),
+    bindingNodeTypes: new Set(['property_declaration']),
+    assignmentNodeTypes: new Set(['assignment']),
+    identifierNodeTypes: new Set(['simple_identifier', 'type_identifier']),
+    extractFunctionParameters: (node) => node.namedChildren.filter((child) => child !== null && child.type === 'parameter'),
+};
 /** tree-sitter-swift node types that carry arity. */
 const FUNCTION_NODE_TYPES = [
     'function_declaration',
@@ -257,6 +268,7 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
     // legacy heritage-capture leg (removed in #942), which the worker pipeline
     // drops for registry-primary languages (issue #1951).
     out.push(...synthesizeSwiftInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, SWIFT_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**

package/dist/core/ingestion/languages/typescript/captures.js

@@ -33,6 +33,7 @@ import { computeTsArityMetadata } from './arity-metadata.js';
 import { isArrayMethodCallbackArrow } from './array-callback.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 import { deriveDefaultExportHocName, isBlockedDefaultExportHoc, isDefaultExportHocFunctionNode, } from '../../ts-js-hoc-utils.js';
 /** tree-sitter-typescript node types for function-like scopes that may
  *  carry a synthesized `this` binding. Kept in sync with the
@@ -55,6 +56,25 @@ const CALL_TAGS = [
     '@reference.call.member',
     '@reference.call.constructor',
 ];
+const TS_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(FUNCTION_NODE_TYPES),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['formal_parameters', 'arguments']),
+    parameterNodeTypes: new Set([
+        'required_parameter',
+        'optional_parameter',
+        'rest_pattern',
+        'identifier',
+    ]),
+    bindingNodeTypes: new Set(['variable_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression', 'augmented_assignment_expression']),
+    identifierNodeTypes: new Set([
+        'identifier',
+        'property_identifier',
+        'shorthand_property_identifier_pattern',
+        'private_property_identifier',
+    ]),
+};
 function pickFirstCapture(grouped, tags) {
     for (const tag of tags) {
         const cap = grouped[tag];
@@ -344,6 +364,7 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
     synthesizeForOfMapTupleBindings(tree.rootNode, out);
     synthesizeInstanceofNarrowings(tree.rootNode, out);
     synthesizeTsInheritanceReferences(tree.rootNode, out);
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, TS_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**

package/dist/core/ingestion/languages/typescript/nuxt-auto-imports.js

@@ -202,7 +202,8 @@ function isProjectLocalPath(source) {
 /** True when `absPath` is `repoRoot` itself or lives beneath it. */
 function isWithinRepo(repoRoot, absPath) {
     const root = path.resolve(repoRoot);
-    return absPath === root || absPath.startsWith(root + path.sep);
+    const safeRoot = root.endsWith(path.sep) ? root : root + path.sep;
+    return absPath === root || absPath.startsWith(safeRoot);
 }
 async function resolveExtension(base) {
     const directFile = await firstExistingFile([...FILE_EXTENSIONS.map((ext) => base + ext), base]);

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

@@ -96,6 +96,23 @@ const TYPESCRIPT_SCOPE_QUERY = `
 (arrow_function) @scope.function
 (function_expression) @scope.function
 
+;; Object literals (the { ... } value expression, NOT object_type or
+;; object_pattern) get their own scope boundary. Without it, a
+;; method_definition/property-arrow's auto-hoist (scope-extractor.ts)
+;; has nowhere to stop and leaks the name past the literal into whatever
+;; lexically encloses it -- e.g. 'export default { async fetch(req) {} }'
+;; would bind fetch at Module scope, letting an unrelated same-file
+;; fetch(...) call (the platform global) incorrectly resolve to it
+;; (#2545). Object (not Block or Class): object-literal members are
+;; reachable only via property access, never as bare identifiers -- not
+;; even by a SIBLING property's function body, unlike a real Block
+;; (if/for/while, where a nested closure legitimately sees a sibling
+;; let/const) or a Class (implicit-this sibling dispatch). Scope-chain
+;; walkers (scope-resolution/scope/walkers.ts) skip an Object scope's
+;; own bindings entirely while still treating it as a hoist boundary
+;; (#2551).
+(object) @scope.object
+
 ;; Type aliases that contain an object_type are structurally class-like —
 ;; they define a shape with named members. Emit @scope.class so the
 ;; field-extractor's type-alias-with-object-type handling (in
@@ -987,6 +1004,26 @@ const TYPESCRIPT_SCOPE_QUERY = `
 (member_expression
   object: (_) @reference.receiver
   property: (property_identifier) @reference.name) @reference.read.member
+
+;; References — value position (#2437): a function identifier assigned as an
+;; object-literal property value (\`{ emitScopeCaptures: emitCppScopeCaptures }\`)
+;; or shorthand (\`{ emitHook }\`). Resolution keeps only callable targets
+;; (MethodRegistry), so plain-value pairs (\`{ port: DEFAULT_PORT }\`) emit
+;; nothing; the emitted edge is a reference-class USES (registration ≠
+;; invocation). \`@reference.property-key\` records the key so the
+;; property-dispatch pass can synthesize CALLS at \`x.<key>()\` sites; for
+;; shorthand the key IS the name (both tags on one node). Two separate
+;; patterns — never combined in \`[...]\` (tree-sitter 0.21 drops alternation
+;; siblings around predicates). Destructuring shorthand is a different node
+;; (\`shorthand_property_identifier_pattern\`), so \`const { a } = o\` cannot
+;; match; string/computed keys carry no \`property_identifier\` and register
+;; without a dispatch key.
+(pair
+  key: (property_identifier) @reference.property-key
+  value: (identifier) @reference.name @reference.value-ref)
+
+(object
+  (shorthand_property_identifier) @reference.name @reference.property-key @reference.value-ref)
 `;
 /**
  * JSX-only query suffix. Appended to the base query when compiling

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

@@ -7,6 +7,7 @@
  */
 import path from 'node:path';
 import { generateId } from '../../lib/utils.js';
+import { toZeroBasedLine } from './utils/line-base.js';
 const HEADING_RE = /^(#{1,6})\s+(.+)$/;
 const LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
 const MD_EXTENSIONS = new Set(['.md', '.mdx']);
@@ -59,8 +60,8 @@ export const processMarkdown = (graph, files, allPathSet) => {
                 properties: {
                     name: heading,
                     filePath: file.path,
-                    startLine: lineNum,
-                    endLine,
+                    startLine: toZeroBasedLine(lineNum),
+                    endLine: toZeroBasedLine(endLine),
                     level,
                     description: `h${level}`,
                 },

package/dist/core/ingestion/model/registration-table.js

@@ -116,6 +116,7 @@ const LABEL_BEHAVIOR = {
     Section: 'inert',
     Route: 'inert',
     Tool: 'inert',
+    EnumVariant: 'inert',
     // Taint/PDG substrate (issue #2080) — a control-flow node, never a
     // symbol-resolution target. Inert: file index only, no owner scope.
     BasicBlock: 'inert',

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

@@ -3,7 +3,7 @@ import type { SymbolTableWriter } from './model/index.js';
 import { type ExportedTypeMap } from './call-processor.js';
 import type { ParsedFile } from '../../_shared/index.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ParseWorkerResult, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileScopeBindings, ExtractedORMQuery, FetchWrapperDef } from './workers/parse-worker.js';
+import type { ParseWorkerResult, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedModuleConstants, ExtractedToolDef, FileScopeBindings, ExtractedORMQuery, FetchWrapperDef } from './workers/parse-worker.js';
 import type { ExtractedRouterConstructorPrefix, ExtractedRouterImport, ExtractedRouterInclude, ExtractedRouterModuleAlias } from './route-extractors/fastapi-router-bindings.js';
 import type { SharedSpringType } from './route-extractors/spring-shared.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
@@ -16,6 +16,8 @@ export interface WorkerExtractedData {
     routerImports: ExtractedRouterImport[];
     routerConstructorPrefixes: ExtractedRouterConstructorPrefix[];
     routerModuleAliases: ExtractedRouterModuleAlias[];
+    /** Per-file Python module constants for cross-file route-path resolution (#2391). */
+    moduleConstants: ExtractedModuleConstants[];
     toolDefs: ExtractedToolDef[];
     ormQueries: ExtractedORMQuery[];
     /** Project-wide Spring class/interface views for the #2288 inheritance pass. */

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

@@ -1,6 +1,33 @@
 import { getLanguageFromFilename } from '../../_shared/index.js';
 import { accumulateExportedTypesFromParsedNode } from './call-processor.js';
 import { logger } from '../logger.js';
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function sourceLine(node) {
+    const value = node.properties.startLine;
+    return typeof value === 'number' && Number.isFinite(value) ? value : Number.MAX_SAFE_INTEGER;
+}
+function compareParsedNodeSourceOrder(left, right) {
+    const leftPath = typeof left.properties.filePath === 'string' ? left.properties.filePath : '';
+    const rightPath = typeof right.properties.filePath === 'string' ? right.properties.filePath : '';
+    const fileOrder = compareText(leftPath, rightPath);
+    if (fileOrder !== 0)
+        return fileOrder;
+    const leftLine = sourceLine(left);
+    const rightLine = sourceLine(right);
+    if (leftLine !== rightLine)
+        return leftLine < rightLine ? -1 : 1;
+    return compareText(left.id, right.id);
+}
+function nodesInSourceOrder(nodes) {
+    for (let index = 1; index < nodes.length; index++) {
+        if (compareParsedNodeSourceOrder(nodes[index - 1], nodes[index]) > 0) {
+            return [...nodes].sort(compareParsedNodeSourceOrder);
+        }
+    }
+    return nodes;
+}
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
@@ -24,13 +51,18 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
     const allRouterImports = [];
     const allRouterConstructorPrefixes = [];
     const allRouterModuleAliases = [];
+    const allModuleConstants = [];
     const allSpringTypes = [];
     const allToolDefs = [];
     const allORMQueries = [];
     const fileScopeBindingsByFile = [];
     const allParsedFiles = [];
     for (const result of chunkResults) {
-        for (const node of result.nodes) {
+        // Worker jobs and input files are already merged in stable start-index/path
+        // order. Canonicalize the final per-result node boundary once so graph
+        // insertion, cache replay, and first-wins graph indexes share source order.
+        // The common already-ordered path stays allocation-free and linear.
+        for (const node of nodesInSourceOrder(result.nodes)) {
             graph.addNode({
                 id: node.id,
                 label: node.label,
@@ -76,6 +108,8 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
         }
         for (const item of result.routerModuleAliases ?? [])
             allRouterModuleAliases.push(item);
+        for (const item of result.moduleConstants ?? [])
+            allModuleConstants.push(item);
         for (const item of result.springTypes ?? [])
             allSpringTypes.push(item);
         for (const item of result.toolDefs)
@@ -99,6 +133,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
         routerImports: allRouterImports,
         routerConstructorPrefixes: allRouterConstructorPrefixes,
         routerModuleAliases: allRouterModuleAliases,
+        moduleConstants: allModuleConstants,
         toolDefs: allToolDefs,
         ormQueries: allORMQueries,
         springTypes: allSpringTypes,

package/dist/core/ingestion/pipeline-phases/index.d.ts

@@ -6,6 +6,7 @@
  */
 export { scanPhase, type ScanOutput } from './scan.js';
 export { structurePhase, type StructureOutput } from './structure.js';
+export { emptyStandaloneIngestPhase, type StandaloneIngestOutput } from './standalone-ingest.js';
 export { markdownPhase, type MarkdownOutput } from './markdown.js';
 export { cobolPhase, type CobolOutput } from './cobol.js';
 export { parsePhase, type ParseOutput } from './parse.js';
@@ -14,6 +15,7 @@ export { toolsPhase, type ToolsOutput, type ToolDef } from './tools.js';
 export { ormPhase, type ORMOutput } from './orm.js';
 export { crossFilePhase, type CrossFileOutput } from './cross-file.js';
 export { scopeResolutionPhase, type ScopeResolutionOutput, } from '../scope-resolution/pipeline/phase.js';
+export { springConfigPhase, type SpringConfigOutput } from './spring-config.js';
 export { pruneLocalSymbolsPhase, type PruneLocalSymbolsOutput } from './prune-local-symbols.js';
 export { taintSummariesPhase, type TaintSummariesOutput } from './taint-summaries.js';
 export { callSummariesPhase, type CallSummariesOutput } from './call-summaries.js';

package/dist/core/ingestion/pipeline-phases/index.js

@@ -7,6 +7,7 @@
 // ── Phase exports (in dependency order) ────────────────────────────────────
 export { scanPhase } from './scan.js';
 export { structurePhase } from './structure.js';
+export { emptyStandaloneIngestPhase } from './standalone-ingest.js';
 export { markdownPhase } from './markdown.js';
 export { cobolPhase } from './cobol.js';
 export { parsePhase } from './parse.js';
@@ -15,6 +16,7 @@ export { toolsPhase } from './tools.js';
 export { ormPhase } from './orm.js';
 export { crossFilePhase } from './cross-file.js';
 export { scopeResolutionPhase, } from '../scope-resolution/pipeline/phase.js';
+export { springConfigPhase } from './spring-config.js';
 export { pruneLocalSymbolsPhase } from './prune-local-symbols.js';
 export { taintSummariesPhase } from './taint-summaries.js';
 export { callSummariesPhase } from './call-summaries.js';

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -17,7 +17,7 @@
 import { BindingAccumulator, enrichExportedTypeMap, } from '../binding-accumulator.js';
 import { mergeChunkResults, dispatchChunkParse } from '../parsing-processor.js';
 import { fileContentHash, computeChunkHash, loadParseCacheChunk, persistParseCacheChunk, PARSE_CACHE_VERSION, } from '../../../storage/parse-cache.js';
-import { clearParsedFileStore, persistParsedFileChunk, getDurableParsedFileDir, loadDurableParsedFileIndex, restoreDurableParsedFileShard, } from '../../../storage/parsedfile-store.js';
+import { clearParsedFileStore, persistParsedFileChunk, getDurableParsedFileDir, loadDurableParsedFileIndex, prepareDurableParsedFileChunk, restoreDurableParsedFileShard, } from '../../../storage/parsedfile-store.js';
 import { DEFAULT_PDG_MAX_FUNCTION_LINES } from '../cfg/collect.js';
 import { processRoutesFromExtracted, resolveRouteHandlerSymbols, buildExportedTypeMapFromGraph, } from '../call-processor.js';
 import { createSemanticModel } from '../model/index.js';
@@ -28,6 +28,7 @@ import { parseSourceSafe } from '../../tree-sitter/safe-parse.js';
 import { getProvider, providers } from '../languages/index.js';
 import { createWorkerPool, workerPoolDisabledByEnv, resolveAutoPoolSize, WorkerPoolInitializationError, WorkerPoolDisabledError, } from '../workers/worker-pool.js';
 import { normalizeExtractedRoutePath } from '../route-extractors/route-path.js';
+import { resolveOperands, } from '../route-extractors/python-const-resolver.js';
 import { resolveInheritedSpringRoutes, } from '../route-extractors/spring-shared.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -277,7 +278,8 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     const skippedByLang = new Map();
     for (const f of scannedFiles) {
         const lang = getLanguageFromFilename(f.path);
-        if (lang && !isLanguageAvailable(lang)) {
+        const provider = lang === null ? undefined : getProvider(lang);
+        if (lang && provider?.parseStrategy !== 'standalone' && !isLanguageAvailable(lang)) {
             skippedByLang.set(lang, (skippedByLang.get(lang) || 0) + 1);
         }
     }
@@ -464,6 +466,9 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     const allRouterImports = [];
     const allRouterConstructorPrefixes = [];
     const allRouterModuleAliases = [];
+    // Per-file Python module constants (#2391); resolved into decorator route paths
+    // below, after cross-file aggregation, alongside the include_router prefix pass.
+    const allModuleConstants = [];
     const allSpringTypes = [];
     const allToolDefs = [];
     const allORMQueries = [];
@@ -610,6 +615,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     for (const item of chunkWorkerData.routerModuleAliases)
                         allRouterModuleAliases.push(item);
                 }
+                if (chunkWorkerData.moduleConstants?.length) {
+                    for (const item of chunkWorkerData.moduleConstants)
+                        allModuleConstants.push(item);
+                }
                 if (chunkWorkerData.springTypes?.length) {
                     for (const item of chunkWorkerData.springTypes)
                         allSpringTypes.push(item);
@@ -769,6 +778,17 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 // Cache miss: dispatch to workers, capture the raw results, store
                 // them under the chunk hash for the next run.
                 chunkCacheMisses++;
+                if (durableParsedFileDir !== undefined && chunkHash !== null) {
+                    try {
+                        await prepareDurableParsedFileChunk(durableParsedFileDir, chunkHash);
+                    }
+                    catch (err) {
+                        // The durable store is an optimization — degrade like the restore
+                        // path does instead of failing the analyze. Workers recreate the
+                        // directory on write, so at worst the old generation lingers.
+                        logger.warn({ err, chunkHash: chunkHash.slice(0, 8) }, 'parsedfile-cache: could not reset durable chunk generation; continuing');
+                    }
+                }
                 const progressForChunk = (current, _total, filePath) => {
                     const globalCurrent = filesParsedSoFar + current;
                     // Parse phase covers 20-70 (M2). Deferred extraction handles 70-95.
@@ -925,6 +945,40 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     }
     // FastAPI router-prefix resolution (cross-file).
     //
+    // #2391: resolve non-literal FastAPI decorator route paths (imported/composed
+    // string constants) BEFORE the include_router/APIRouter prefix pass below, so a
+    // resolved path is then prefix-joined like any literal path. Each such route
+    // carries `routePathExpr`/`routePathOperands` and an empty `routePath`; we fold
+    // the operands against the repo-wide, file-path-keyed constant map. On failure
+    // we DROP the route (KTD5 skip floor) rather than emit a phantom `POST /`.
+    if (allDecoratorRoutes.some((dr) => dr.routePathExpr !== undefined)) {
+        const repoConstants = new Map();
+        for (const { filePath, constants } of allModuleConstants) {
+            repoConstants.set(filePath, constants);
+        }
+        const resolvedRoutes = [];
+        let skipped = 0;
+        for (const dr of allDecoratorRoutes) {
+            if (dr.routePathExpr === undefined) {
+                resolvedRoutes.push(dr);
+                continue;
+            }
+            const value = dr.routePathOperands
+                ? resolveOperands(dr.filePath, dr.routePathOperands, repoConstants)
+                : null;
+            if (value === null) {
+                skipped++;
+                continue;
+            }
+            resolvedRoutes.push({ ...dr, routePath: value });
+        }
+        allDecoratorRoutes.length = 0;
+        for (const dr of resolvedRoutes)
+            allDecoratorRoutes.push(dr);
+        if (isDev && skipped > 0) {
+            logger.info(`  🧩 Resolved composed route constants; ${skipped} unresolved route(s) skipped`);
+        }
+    }
     // Workers emit two kinds of records per Python file:
     //   • `routerIncludes` — every `app.include_router(<routerExpr>, prefix='/x')`
     //     site, where `routerExpr` is either `<module>.router` (Shape A) or a

package/dist/core/ingestion/pipeline-phases/parse.d.ts

@@ -48,8 +48,6 @@ export interface ParseOutput {
     model: MutableSemanticModel;
     /** Pass-through: all file paths for downstream phases. */
     readonly allPaths: readonly string[];
-    /** Pass-through: shared `allPathSet` from structure (built once, not per-phase). */
-    readonly allPathSet: ReadonlySet<string>;
     /** Pass-through: total file count for progress reporting. */
     totalFiles: number;
     /**

package/dist/core/ingestion/pipeline-phases/parse.js

@@ -19,14 +19,23 @@ import { getPhaseOutput } from './types.js';
 import { runChunkedParseAndResolve } from './parse-impl.js';
 export const parsePhase = {
     name: 'parse',
-    deps: ['structure', 'markdown', 'cobol'],
+    deps: ['structure', 'standaloneIngest', 'markdown', 'cobol'],
     async execute(ctx, deps) {
-        const { scannedFiles, allPaths, allPathSet, totalFiles } = getPhaseOutput(deps, 'structure');
+        const structure = getPhaseOutput(deps, 'structure');
+        const { totalFiles } = structure;
+        // Files claimed by a standalone ingester must not be parsed a second time.
+        const standaloneIngest = getPhaseOutput(deps, 'standaloneIngest');
+        const ingested = standaloneIngest.ingestedFiles;
+        const scannedFiles = ingested.size
+            ? structure.scannedFiles.filter((f) => !ingested.has(f.path))
+            : structure.scannedFiles;
+        const allPaths = ingested.size
+            ? structure.allPaths.filter((p) => !ingested.has(p))
+            : structure.allPaths;
         const result = await runChunkedParseAndResolve(ctx.graph, scannedFiles, allPaths, totalFiles, ctx.repoPath, ctx.pipelineStart, ctx.onProgress, ctx.options);
         return {
             ...result,
             allPaths,
-            allPathSet,
             totalFiles,
         };
     },

package/dist/core/ingestion/pipeline-phases/processes.d.ts

@@ -13,4 +13,12 @@ import { type ProcessDetectionResult } from '../process-processor.js';
 export interface ProcessesOutput {
     processResult: ProcessDetectionResult;
 }
+/**
+ * Compute the dynamic max-processes budget from the symbol count.
+ *
+ * Scales proportionally (symbolCount / 10) with a floor of 20.
+ * Prior to #2198 this was capped at 300 via `Math.min(300, …)`,
+ * silently truncating process detection on large repositories.
+ */
+export declare function computeDynamicMaxProcesses(symbolCount: number): number;
 export declare const processesPhase: PipelinePhase<ProcessesOutput>;

package/dist/core/ingestion/pipeline-phases/processes.js

@@ -14,6 +14,16 @@ import { generateId } from '../../../lib/utils.js';
 import { routeNodeKey } from '../route-extractors/route-path.js';
 import { isDev } from '../utils/env.js';
 import { logger } from '../../logger.js';
+/**
+ * Compute the dynamic max-processes budget from the symbol count.
+ *
+ * Scales proportionally (symbolCount / 10) with a floor of 20.
+ * Prior to #2198 this was capped at 300 via `Math.min(300, …)`,
+ * silently truncating process detection on large repositories.
+ */
+export function computeDynamicMaxProcesses(symbolCount) {
+    return Math.max(20, Math.round(symbolCount / 10));
+}
 export const processesPhase = {
     name: 'processes',
     // `structure` supplies `totalFiles` (progress counter) without the spurious
@@ -37,7 +47,7 @@ export const processesPhase = {
             if (n.label !== 'File')
                 symbolCount++;
         });
-        const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10)));
+        const dynamicMaxProcesses = computeDynamicMaxProcesses(symbolCount);
         const processResult = await processProcesses(ctx.graph, communityResult.memberships, (message, progress) => {
             const processProgress = 99 + progress * 0.01;
             ctx.onProgress({

package/dist/core/ingestion/pipeline-phases/spring-config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Phase: springConfig
+ *
+ * Adds key-only nodes for statically readable Spring
+ * `application*.properties` / `application*.yml` / `application*.yaml` files.
+ * Language-specific ScopeResolver hooks attach consumers later. Configuration
+ * values are deliberately never copied into the graph because they may contain
+ * credentials and key identity is sufficient for impact analysis.
+ *
+ * @deps    structure
+ * @reads   Spring application configuration files
+ * @writes  Property nodes and DEFINES edges
+ */
+import type { PipelinePhase } from './types.js';
+export interface SpringConfigKey {
+    readonly key: string;
+    readonly filePath: string;
+    readonly line: number;
+    readonly profile?: string;
+    readonly format: 'properties' | 'yaml';
+}
+interface SpringConfigFile {
+    readonly filePath: string;
+    readonly profile?: string;
+    readonly format: SpringConfigKey['format'];
+}
+export interface SpringConfigOutput {
+    readonly configKeys: number;
+}
+/** Match only Spring Boot's conventional application config file names. */
+export declare function classifySpringConfigFile(filePath: string): SpringConfigFile | null;
+/** Parse `.properties` keys without retaining their values. */
+export declare function parseSpringProperties(content: string, filePath: string, profile?: string): SpringConfigKey[];
+/** Parse and flatten YAML leaves without retaining their values. */
+export declare function parseSpringYaml(content: string, filePath: string, profile?: string): SpringConfigKey[];
+export declare const springConfigPhase: PipelinePhase<SpringConfigOutput>;
+export {};