codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/services/AstParserService.js

@@ -37,29 +37,36 @@ exports.AstParserService = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const ts_morph_1 = require("ts-morph");
+const DeclarationTreeBuilder_1 = require("../declarations/DeclarationTreeBuilder");
+const DeclarationTree_1 = require("../declarations/DeclarationTree");
 const LoggerService_1 = require("./LoggerService");
-const GRAPHQL_MODULE = '@nestjs/graphql';
-const GRAPHQL_TYPE_DECORATORS = new Set(['ObjectType', 'InputType', 'InterfaceType']);
-const GRAPHQL_OPERATION_KIND = {
-    Query: 'graphql_query', Mutation: 'graphql_mutation', Subscription: 'graphql_subscription',
-};
-const GRAPHQL_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/;
+const IndexedNodeResolver_1 = require("../ast/IndexedNodeResolver");
+const ImportEdgeExtractor_1 = require("../ast/ImportEdgeExtractor");
+const TopLevelSymbolExtractor_1 = require("../ast/TopLevelSymbolExtractor");
+const MemberExtractor_1 = require("../ast/MemberExtractor");
+const CallExtractor_1 = require("../ast/CallExtractor");
+const GraphqlNameExtractor_1 = require("../ast/GraphqlNameExtractor");
 const FALLBACK_OPTS = {
     skipAddingFilesFromTsConfig: true,
     skipFileDependencyResolution: false,
     compilerOptions: { allowJs: true, noEmit: true },
 };
 const MORPH_CACHE_MAX = 10;
-const VALID_SEGMENT = /^#?[\w$]+$/;
 class AstParserService {
     logger;
-    deps;
     morphProjects = new Map();
+    declarationBuilder = new DeclarationTreeBuilder_1.DeclarationTreeBuilder();
+    resolver = new IndexedNodeResolver_1.IndexedNodeResolver();
+    edges;
+    topLevel = new TopLevelSymbolExtractor_1.TopLevelSymbolExtractor();
+    members = new MemberExtractor_1.MemberExtractor(this.resolver);
+    calls = new CallExtractor_1.CallExtractor(this.resolver);
+    graphql;
     constructor(logger = LoggerService_1.LoggerService.silent(), deps = {}) {
         this.logger = logger;
-        this.deps = deps;
+        this.edges = new ImportEdgeExtractor_1.ImportEdgeExtractor(logger);
+        this.graphql = new GraphqlNameExtractor_1.GraphqlNameExtractor(this.resolver, logger, deps.resolveDeclaration);
     }
-    // ── public interface ────────────────────────────────────────────────────────
     async analyzeProject(filePaths, serviceName, projectRoot = process.cwd(), opts = {}) {
         const t0 = Date.now();
         const skipDependencyResolution = opts.skipDependencyResolution ?? false;
@@ -76,7 +83,7 @@ class AstParserService {
                 morphProject.addSourceFileAtPath(filePath);
             }
             catch (err) {
-                this.logger.warn('AstParser: failed to add source file', { filePath, reason: err.message });
+                this.logger.warn('AstParser: failed to add source file', { filePath, err });
                 analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] });
             }
         }
@@ -84,7 +91,6 @@ class AstParserService {
             const filePath = sourceFile.getFilePath();
             analysisMap.set(filePath, this.analyzeSourceFile(sourceFile, filePath, serviceName));
         }
-        // Release source file memory before returning
         for (const sourceFile of morphProject.getSourceFiles()) {
             morphProject.removeSourceFile(sourceFile);
         }
@@ -120,7 +126,7 @@ class AstParserService {
             sourceFile = morphProject.addSourceFileAtPath(filePath);
         }
         catch (err) {
-            this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, reason: err.message, ms: Date.now() - t0 });
+            this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, err, ms: Date.now() - t0 });
             return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
         const result = this.analyzeSourceFile(sourceFile, filePath, serviceName);
@@ -130,64 +136,46 @@ class AstParserService {
         });
         return result;
     }
-    // Kept for test compatibility (extract-import-edges.test.ts).
     async extractImportEdges(filePath, serviceName, projectRoot) {
         const { edges } = await this.analyzeFile(filePath, serviceName, projectRoot);
         return edges;
     }
     analyzeSourceFile(sourceFile, filePath, serviceName) {
         try {
-            const edges = this.extractEdges(sourceFile, filePath, serviceName);
-            const symbolCandidates = this.extractSymbols(sourceFile, filePath, serviceName);
+            const edges = this.edges.extractEdges(sourceFile, filePath, serviceName);
+            const symbolCandidates = this.topLevel.extractSymbols(sourceFile, filePath, serviceName);
             const symbols = symbolCandidates.map(c => c.entry);
-            // Member extraction (classes anywhere, class/interface/object-literal
-            // members, namespace-level declarations) is isolated in its own try: a
-            // bug there must never change a file's top-level symbols, chunks or
-            // embedding prompt (see the `symbol-index-members` retrieval-invariance
-            // requirement).
             let memberCandidates = [];
             try {
-                memberCandidates = this.extractMembers(sourceFile, filePath, serviceName);
+                memberCandidates = this.members.extractMembers(sourceFile, filePath, serviceName);
             }
             catch (err) {
-                this.logger.warn('AstParser: member extraction failed', { filePath, reason: err.message });
+                this.logger.warn('AstParser: member extraction failed', { filePath, err });
                 memberCandidates = [];
             }
             const members = memberCandidates.map(c => c.entry);
-            const calls = this.extractCalls(sourceFile, filePath, serviceName);
-            const ownerRanges = this.buildOwnerRanges([...symbolCandidates, ...memberCandidates]);
-            // GraphQL-named rows are isolated like members: a bug here must never
-            // change a file's symbols, members, chunks, ownerPath or call graph.
-            // Runs after member extraction (decision 6 of `graphql-symbols`) — a
-            // GraphQL row is written only when the decorated declaration's own row
-            // was written to code_symbol.
+            const calls = this.calls.extractCalls(sourceFile, filePath, serviceName);
+            const declarations = this.buildDeclarations(sourceFile, filePath, symbolCandidates, memberCandidates);
             let graphqlNames = [];
             try {
-                graphqlNames = this.extractGraphqlNames(sourceFile, filePath, serviceName, [...symbolCandidates, ...memberCandidates]);
+                graphqlNames = this.graphql.extractGraphqlNames(sourceFile, filePath, serviceName, [...symbolCandidates, ...memberCandidates]);
             }
             catch (err) {
-                this.logger.warn('AstParser: GraphQL extraction failed', { filePath, reason: err.message });
+                this.logger.warn('AstParser: GraphQL extraction failed', { filePath, err });
                 graphqlNames = [];
             }
-            return { edges, symbols, members, calls, ownerRanges, graphqlNames };
+            return { edges, symbols, members, calls, declarations, graphqlNames };
         }
         catch (err) {
-            this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
+            this.logger.warn('AstParser: failed to analyze file', { filePath, err });
             return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
     }
-    // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
     createMorphProject(projectRoot, skipFileDependencyResolution = false, rootTsConfigPath) {
         const t0 = Date.now();
-        // Determine which tsconfig to use:
-        // 1. Project-local tsconfig.json
-        // 2. Root tsconfig (e.g. tsconfig.base.json for Nx monorepos)
-        // 3. Fallback options
         const localTsconfigPath = path.join(projectRoot, 'tsconfig.json');
         const hasLocalTsconfig = fs.existsSync(localTsconfigPath);
         const hasRootTsconfig = rootTsConfigPath ? fs.existsSync(rootTsConfigPath) : false;
-        // For monorepos: prefer the root tsconfig.base.json which contains
-        // workspace-wide path aliases (e.g. @scope/* → libs/*/src)
         const effectiveTsconfig = hasRootTsconfig ? rootTsConfigPath : (hasLocalTsconfig ? localTsconfigPath : null);
         this.logger.debug('AstParser: tsconfig lookup', {
             projectRoot,
@@ -219,7 +207,7 @@ class AstParserService {
         catch (err) {
             this.logger.warn('AstParser: tsconfig load failed, using fallback', {
                 tsconfigPath: effectiveTsconfig ?? localTsconfigPath,
-                reason: err.message,
+                err,
                 ms: Date.now() - t0,
             });
             project = new ts_morph_1.Project(FALLBACK_OPTS);
@@ -228,7 +216,6 @@ class AstParserService {
     }
     getMorphProject(projectRoot) {
         if (this.morphProjects.has(projectRoot)) {
-            // Move to end = most recently used
             const cached = this.morphProjects.get(projectRoot);
             this.morphProjects.delete(projectRoot);
             this.morphProjects.set(projectRoot, cached);
@@ -236,7 +223,6 @@ class AstParserService {
             return cached;
         }
         if (this.morphProjects.size >= MORPH_CACHE_MAX) {
-            // Evict least recently used (first entry in insertion-order Map)
             const lruKey = this.morphProjects.keys().next().value;
             this.morphProjects.delete(lruKey);
             this.logger.debug('AstParser: evicted LRU project', { lruKey });
@@ -246,1036 +232,19 @@ class AstParserService {
         this.morphProjects.set(projectRoot, project);
         return project;
     }
-    // ── private: edge extraction (imports + re-exports) ────────────────────────
-    extractEdges(sourceFile, filePath, serviceName) {
-        const edges = [];
-        const usageMap = this.buildUsageMap(sourceFile);
-        for (const decl of sourceFile.getImportDeclarations()) {
-            const namedImports = decl.getNamedImports();
-            const defaultImport = decl.getDefaultImport();
-            const namespaceImport = decl.getNamespaceImport();
-            const hasClause = Boolean(defaultImport || namespaceImport || namedImports.length > 0);
-            const resolved = decl.getModuleSpecifierSourceFile();
-            let toFile = resolved ? resolved.getFilePath() : null;
-            // A bindingless specifier never resolves through ts-morph's bound symbol
-            // (nothing is bound), even for a real project file — fall back to
-            // TypeScript's own resolver and map the result back onto the project.
-            if (!toFile && !hasClause) {
-                toFile = this.resolveSideEffectModuleSpecifier(decl, sourceFile, filePath);
-            }
-            if (!toFile) {
-                const specifier = decl.getModuleSpecifierValue();
-                const isCodeImport = !/\.(json|css|scss|less|svg|png|jpg|gif|ico|woff2?|ttf|eot)(\?.*)?$/.test(specifier);
-                if (specifier.startsWith('.') && isCodeImport) {
-                    this.logger.debug('AstParser: unresolved import', { specifier, file: filePath });
-                }
-                continue;
-            }
-            if (toFile.includes('/node_modules/'))
-                continue;
-            if (!hasClause) {
-                edges.push({
-                    project: serviceName, fromFile: filePath, fromSymbol: null,
-                    toFile, toSymbol: null, depType: 'import-side-effect',
-                });
-                continue;
-            }
-            if (defaultImport) {
-                const fromSymbol = this.resolveFromSymbol(defaultImport.getText(), usageMap);
-                edges.push({
-                    project: serviceName, fromFile: filePath, fromSymbol,
-                    toFile, toSymbol: null, depType: 'import-default',
-                });
-            }
-            if (namespaceImport) {
-                const fromSymbol = this.resolveFromSymbol(namespaceImport.getText(), usageMap);
-                edges.push({
-                    project: serviceName, fromFile: filePath, fromSymbol,
-                    toFile, toSymbol: null, depType: 'import-namespace',
-                });
-            }
-            for (const named of namedImports) {
-                const localName = named.getAliasNode()?.getText() ?? named.getName();
-                const fromSymbol = this.resolveFromSymbol(localName, usageMap);
-                edges.push({
-                    project: serviceName, fromFile: filePath, fromSymbol,
-                    toFile, toSymbol: named.getName(), depType: 'import',
-                });
-            }
-        }
-        for (const decl of sourceFile.getExportDeclarations()) {
-            const resolved = decl.getModuleSpecifierSourceFile();
-            if (!resolved)
-                continue;
-            const toFile = resolved.getFilePath();
-            if (toFile.includes('/node_modules/'))
-                continue;
-            const namedExports = decl.getNamedExports();
-            if (namedExports.length > 0) {
-                for (const named of namedExports) {
-                    edges.push({
-                        project: serviceName, fromFile: filePath, fromSymbol: null,
-                        toFile, toSymbol: named.getName(), depType: 'reexport',
-                    });
-                }
-            }
-            else {
-                edges.push({
-                    project: serviceName, fromFile: filePath, fromSymbol: null,
-                    toFile, toSymbol: null, depType: 'reexport-namespace',
-                });
-            }
-        }
-        return edges;
-    }
-    /** Manual fallback for a bindingless import specifier (design.md decision 2) —
-     * ts-morph's `getModuleSpecifierSourceFile()` is `null` for these even when
-     * the target is a real project file, since nothing is bound to resolve through. */
-    resolveSideEffectModuleSpecifier(decl, sourceFile, filePath) {
-        const specifier = decl.getModuleSpecifierValue();
-        const compilerOptions = sourceFile.getProject().getCompilerOptions();
-        const result = ts_morph_1.ts.resolveModuleName(specifier, filePath, compilerOptions, ts_morph_1.ts.sys);
-        const resolvedFileName = result.resolvedModule?.resolvedFileName;
-        if (!resolvedFileName)
-            return null;
-        return sourceFile.getProject().getSourceFile(resolvedFileName)?.getFilePath() ?? null;
-    }
-    resolveFromSymbol(localName, usageMap) {
-        const users = usageMap.get(localName);
-        return users?.length === 1 ? users[0] : null;
-    }
-    buildUsageMap(sourceFile) {
-        const map = new Map();
-        const containers = [
-            ...sourceFile.getClasses().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
-            ...sourceFile.getFunctions().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
-            // include top-level variable declarations so arrow function exports are tracked for fromSymbol
-            ...sourceFile.getVariableStatements()
-                .flatMap(stmt => stmt.getDeclarations())
-                .flatMap(n => {
-                const name = n.getName();
-                return name ? [{ name, node: n }] : [];
-            }),
-        ];
-        for (const { name, node } of containers) {
-            for (const id of node.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier)) {
-                const text = id.getText();
-                const existing = map.get(text);
-                if (existing) {
-                    if (!existing.includes(name))
-                        existing.push(name);
-                }
-                else {
-                    map.set(text, [name]);
-                }
-            }
-        }
-        return map;
-    }
-    // ── private: position / signature helpers ───────────────────────────────────
-    getPos(sourceFile, node) {
-        const { line, character } = sourceFile.compilerNode
-            .getLineAndCharacterOfPosition(node.getStart());
-        return { line: line + 1, col: character + 1 };
-    }
-    /** Trimmed text of the source line containing `node`'s start — the signature
-     * rule for every kind (name node for members, the position node for
-     * constructors/anonymous default classes). */
-    lineTextAt(sourceLines, sourceFile, node) {
-        const { line } = this.getPos(sourceFile, node);
-        return (sourceLines[line - 1] ?? node.getText().split('\n')[0]).trim();
-    }
-    // ── private: top-level symbol extraction (feeds the chunker + prompt) ──────
-    extractSymbols(sourceFile, filePath, serviceName) {
-        const candidates = [];
-        const sourceLines = sourceFile.getFullText().split('\n');
-        const lineAt = (node) => this.lineTextAt(sourceLines, sourceFile, node);
-        for (const cls of sourceFile.getClasses()) {
-            const name = cls.getName();
-            if (!name)
-                continue;
-            const nameNode = cls.getNameNode() ?? cls;
-            const { line, col } = this.getPos(sourceFile, nameNode);
-            candidates.push({
-                declNode: cls,
-                entry: {
-                    project: serviceName, filePath, name, kind: 'class',
-                    signature: lineAt(nameNode),
-                    line, endLine: cls.getEndLineNumber(), col,
-                    container: null, isStatic: false,
-                },
-            });
-        }
-        for (const fn of sourceFile.getFunctions()) {
-            const name = fn.getName();
-            if (!name)
-                continue;
-            const nameNode = fn.getNameNode() ?? fn;
-            const { line, col } = this.getPos(sourceFile, nameNode);
-            candidates.push({
-                declNode: fn,
-                entry: {
-                    project: serviceName, filePath, name, kind: 'function',
-                    signature: lineAt(nameNode),
-                    line, endLine: fn.getEndLineNumber(), col,
-                    container: null, isStatic: false, hasBody: fn.getBody() !== undefined,
-                },
-            });
-        }
-        for (const iface of sourceFile.getInterfaces()) {
-            const nameNode = iface.getNameNode();
-            const { line, col } = this.getPos(sourceFile, nameNode);
-            candidates.push({
-                declNode: iface,
-                entry: {
-                    project: serviceName, filePath, name: iface.getName(), kind: 'interface',
-                    signature: lineAt(nameNode),
-                    line, endLine: iface.getEndLineNumber(), col,
-                    container: null, isStatic: false,
-                },
-            });
-        }
-        for (const ta of sourceFile.getTypeAliases()) {
-            const nameNode = ta.getNameNode();
-            const { line, col } = this.getPos(sourceFile, nameNode);
-            candidates.push({
-                declNode: ta,
-                entry: {
-                    project: serviceName, filePath, name: ta.getName(), kind: 'type',
-                    signature: lineAt(nameNode),
-                    line, endLine: ta.getEndLineNumber(), col,
-                    container: null, isStatic: false,
-                },
-            });
-        }
-        for (const stmt of sourceFile.getVariableStatements()) {
-            for (const decl of stmt.getDeclarations()) {
-                const nameNode = decl.getNameNode();
-                const { line, col } = this.getPos(sourceFile, nameNode);
-                candidates.push({
-                    // Owner ranges use the declarator's own span, not the statement's —
-                    // each declarator of `const a = 1, b = () => {…}` owns only its lines.
-                    declNode: decl,
-                    entry: {
-                        project: serviceName, filePath, name: decl.getName(), kind: 'variable',
-                        signature: lineAt(nameNode),
-                        line, endLine: stmt.getEndLineNumber(), col,
-                        container: null, isStatic: false,
-                    },
-                });
-            }
-        }
-        return candidates;
-    }
-    // ── private: member extraction (classes anywhere, members, namespace body) ─
-    extractMembers(sourceFile, filePath, serviceName) {
-        const candidates = [];
-        const sourceLines = sourceFile.getFullText().split('\n');
-        const lineAt = (node) => this.lineTextAt(sourceLines, sourceFile, node);
-        const push = (declNode, posNode, name, kind, container, isStatic, hasBody) => {
-            const { line, col } = this.getPos(sourceFile, posNode);
-            candidates.push({
-                declNode,
-                entry: {
-                    project: serviceName, filePath, name, kind,
-                    signature: lineAt(posNode),
-                    line, endLine: declNode.getEndLineNumber(), col,
-                    container: container.length ? container.join('.') : null,
-                    isStatic, hasBody,
-                },
-            });
-        };
-        // Classes anywhere in the file — nested, expression, anonymous default.
-        for (const cls of [
-            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration),
-            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassExpression),
-        ]) {
-            // Named top-level classes are already handled by extractSymbols; an
-            // anonymous top-level class (`export default class {}`) is not — it
-            // must still be collected here.
-            if (ts_morph_1.Node.isClassDeclaration(cls) && cls.getName() && ts_morph_1.Node.isSourceFile(cls.getParent()))
-                continue;
-            const described = this.describeIndexedNode(cls);
-            if (!described)
-                continue;
-            const posNode = (ts_morph_1.Node.isClassDeclaration(cls) ? cls.getNameNode() : undefined) ?? cls;
-            push(cls, posNode, described.name, 'class', described.container, false, true);
-        }
-        // Class / object-literal methods, accessors, constructors, function properties.
-        for (const m of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
-            const described = this.describeIndexedNode(m);
-            if (!described)
-                continue;
-            push(m, m.getNameNode(), described.name, 'method', described.container, m.isStatic(), m.getBody() !== undefined);
-        }
-        for (const a of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.GetAccessor)) {
-            const described = this.describeIndexedNode(a);
-            if (!described)
-                continue;
-            push(a, a.getNameNode(), described.name, 'get_accessor', described.container, a.isStatic(), true);
-        }
-        for (const a of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.SetAccessor)) {
-            const described = this.describeIndexedNode(a);
-            if (!described)
-                continue;
-            push(a, a.getNameNode(), described.name, 'set_accessor', described.container, a.isStatic(), true);
-        }
-        for (const c of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.Constructor)) {
-            const described = this.describeIndexedNode(c);
-            if (!described)
-                continue;
-            const kw = c.getFirstChildByKind(ts_morph_1.SyntaxKind.ConstructorKeyword) ?? c;
-            push(c, kw, described.name, 'constructor', described.container, false, c.getBody() !== undefined);
-        }
-        for (const p of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyDeclaration)) {
-            const described = this.describeIndexedNode(p);
-            if (!described)
-                continue;
-            push(p, p.getNameNode(), described.name, 'function_property', described.container, p.isStatic(), true);
-        }
-        for (const p of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
-            const described = this.describeIndexedNode(p);
-            if (!described)
-                continue;
-            push(p, p.getNameNode(), described.name, 'function_property', described.container, false, true);
-        }
-        // Interface / type-literal method and function-typed property signatures.
-        for (const s of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodSignature)) {
-            const described = this.describeIndexedNode(s);
-            if (!described)
-                continue;
-            push(s, s.getNameNode(), described.name, 'method_signature', described.container, false, false);
-        }
-        for (const s of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertySignature)) {
-            const described = this.describeIndexedNode(s);
-            if (!described)
-                continue;
-            push(s, s.getNameNode(), described.name, 'method_signature', described.container, false, false);
-        }
-        // Declarations directly in a namespace body.
-        for (const fn of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionDeclaration)) {
-            if (!ts_morph_1.Node.isModuleBlock(fn.getParent()))
-                continue;
-            const described = this.describeIndexedNode(fn);
-            if (!described)
-                continue;
-            const nameNode = fn.getNameNode();
-            if (!nameNode)
-                continue;
-            push(fn, nameNode, described.name, 'function', described.container, false, fn.getBody() !== undefined);
-        }
-        for (const iface of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.InterfaceDeclaration)) {
-            if (!ts_morph_1.Node.isModuleBlock(iface.getParent()))
-                continue;
-            const described = this.describeIndexedNode(iface);
-            if (!described)
-                continue;
-            push(iface, iface.getNameNode(), described.name, 'interface', described.container, false, true);
-        }
-        for (const ta of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.TypeAliasDeclaration)) {
-            if (!ts_morph_1.Node.isModuleBlock(ta.getParent()))
-                continue;
-            const described = this.describeIndexedNode(ta);
-            if (!described)
-                continue;
-            push(ta, ta.getNameNode(), described.name, 'type', described.container, false, true);
-        }
-        for (const stmt of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.VariableStatement)) {
-            if (!ts_morph_1.Node.isModuleBlock(stmt.getParent()))
-                continue;
-            for (const decl of stmt.getDeclarations()) {
-                const described = this.describeIndexedNode(decl);
-                if (!described)
-                    continue;
-                push(decl, decl.getNameNode(), described.name, 'variable', described.container, false, true);
-            }
-        }
-        return candidates;
-    }
-    /** Chunk-ownership ranges from every indexed declaration (top-level symbols +
-     * members) except `method_signature`. Each range spans the declaration node's
-     * own first-to-last line — decorator-inclusive, comment-exclusive, and (for a
-     * variable) the declarator alone, never the whole statement. */
-    buildOwnerRanges(candidates) {
-        return candidates
-            .filter(c => c.entry.kind !== 'method_signature')
-            .map(c => ({
-            name: c.entry.name,
-            container: c.entry.container,
-            line: c.declNode.getStartLineNumber(),
-            endLine: c.declNode.getEndLineNumber(),
-        }));
-    }
-    // ── private: GraphQL-named rows (graphql-symbols) ───────────────────────────
-    /** Local name → the name exported by `@nestjs/graphql`, for every named import
-     * of that module specifier (aliases followed). Recognition is import-based,
-     * not type-checker-based, so `skipFileDependencyResolution` batches agree. */
-    buildGraphqlImportMap(sourceFile) {
-        const map = new Map();
-        for (const decl of sourceFile.getImportDeclarations()) {
-            if (decl.getModuleSpecifierValue() !== GRAPHQL_MODULE)
-                continue;
-            for (const named of decl.getNamedImports()) {
-                const exportedName = named.getName();
-                const localName = named.getAliasNode()?.getText() ?? exportedName;
-                map.set(localName, exportedName);
-            }
-        }
-        return map;
-    }
-    /** The identifier naming a decorator's expression (`@Foo` or the callee of `@Foo(...)`). */
-    static decoratorIdentifier(dec) {
-        const expr = dec.getExpression();
-        if (ts_morph_1.Node.isCallExpression(expr)) {
-            const callee = expr.getExpression();
-            return ts_morph_1.Node.isIdentifier(callee) ? callee : undefined;
-        }
-        return ts_morph_1.Node.isIdentifier(expr) ? expr : undefined;
-    }
-    /** `dec` recognised against `importMap` — its exported `@nestjs/graphql` name and its call arguments (`[]` for a bare `@Foo`). */
-    recognizedDecorator(dec, importMap) {
-        const idNode = AstParserService.decoratorIdentifier(dec);
-        if (!idNode)
-            return null;
-        const exported = importMap.get(idNode.getText());
-        if (!exported)
-            return null;
-        const expr = dec.getExpression();
-        const args = ts_morph_1.Node.isCallExpression(expr) ? expr.getArguments() : [];
-        return { name: exported, args };
-    }
-    static literalStringValue(node) {
-        if (ts_morph_1.Node.isStringLiteral(node) || ts_morph_1.Node.isNoSubstitutionTemplateLiteral(node))
-            return node.getLiteralValue();
-        return null;
-    }
-    static checkGraphqlGrammar(name) {
-        return GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, reason: 'invalid-name', value: name };
-    }
-    /** `true` when any decorator argument is an (unwrapped) options object
-     * literal with `isAbstract: true` — an abstract base type (`PaginatedType`
-     * pattern) that NestJS never registers in the actual GraphQL schema. */
-    static isAbstractGraphqlType(args) {
-        return args.some((arg) => {
-            if (!ts_morph_1.Node.isObjectLiteralExpression(arg))
-                return false;
-            const prop = arg.getProperties().find((p) => {
-                if (!ts_morph_1.Node.isPropertyAssignment(p))
-                    return false;
-                const nameNode = p.getNameNode();
-                if (ts_morph_1.Node.isIdentifier(nameNode))
-                    return nameNode.getText() === 'isAbstract';
-                if (ts_morph_1.Node.isStringLiteral(nameNode))
-                    return nameNode.getLiteralValue() === 'isAbstract';
-                return false;
-            });
-            const init = prop?.getInitializer();
-            return init !== undefined && ts_morph_1.Node.isTrueLiteral(init);
-        });
-    }
-    /** `obj`'s own `name` property (`PropertyAssignment` or `ShorthandPropertyAssignment`), if any. */
-    static findNameProperty(obj) {
-        return obj.getProperties().find((p) => {
-            if (!ts_morph_1.Node.isPropertyAssignment(p) && !ts_morph_1.Node.isShorthandPropertyAssignment(p))
-                return false;
-            const nameNode = p.getNameNode();
-            if (ts_morph_1.Node.isIdentifier(nameNode))
-                return nameNode.getText() === 'name';
-            if (ts_morph_1.Node.isStringLiteral(nameNode))
-                return nameNode.getLiteralValue() === 'name';
-            return false;
-        });
-    }
-    /** Strips parens/`as`/`satisfies`/non-null wrappers (any nesting) to find the
-     * underlying node — used only to classify an argument's *shape* (type
-     * function vs. options object vs. literal vs. other), never to read a name
-     * value through the wrapper (decision 4 of `graphql-symbols` forbids that). */
-    static peekThroughWrapper(node) {
-        let current = node;
-        let wrapped = false;
-        while (true) {
-            if (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current) || ts_morph_1.Node.isNonNullExpression(current)) {
-                current = current.getExpression();
-                wrapped = true;
-                continue;
-            }
-            break;
-        }
-        return { inner: current, wrapped };
-    }
-    /**
-     * GraphQL name from a decorator's arguments (design decision 4 of
-     * `graphql-symbols`) — syntactic, no wrapper looked through at any step.
-     * `allowOptionsName` gates step 2 (the `name` option — `Query`/`Mutation`/
-     * `Subscription`/`ResolveField` only); `fallbackName` is the TS name used at
-     * step 3.
-     */
-    deriveGraphqlName(args, allowOptionsName, fallbackName) {
-        if (args.length > 0) {
-            const first = args[0];
-            const { inner, wrapped } = AstParserService.peekThroughWrapper(first);
-            const literal = AstParserService.literalStringValue(inner);
-            if (literal !== null) {
-                // A wrapped literal is still "a wrapped ... argument", an anything-else
-                // node (decision 4) — reading its value through the wrapper is exactly
-                // what "no wrapper is looked through" forbids.
-                if (wrapped)
-                    return { ok: false, reason: 'non-literal-name' };
-                return AstParserService.checkGraphqlGrammar(literal);
-            }
-            const isTypeFnOrOptions = ts_morph_1.Node.isArrowFunction(inner) || ts_morph_1.Node.isFunctionExpression(inner) || ts_morph_1.Node.isObjectLiteralExpression(inner);
-            if (!isTypeFnOrOptions)
-                return { ok: false, reason: 'non-literal-name' };
-            // Type function / options object, wrapped or not — this is a routing
-            // decision only (go to step 2/3); nothing is read from it here, so its
-            // wrapper doesn't matter yet.
-        }
-        if (allowOptionsName) {
-            for (const arg of args) {
-                const { inner, wrapped } = AstParserService.peekThroughWrapper(arg);
-                if (!ts_morph_1.Node.isObjectLiteralExpression(inner))
-                    continue;
-                // A wrapped options object cannot be trusted without looking through
-                // the wrapper, which decision 4 forbids — treat it as non-literal
-                // rather than silently skipping to the next argument or to step 3.
-                if (wrapped)
-                    return { ok: false, reason: 'non-literal-name' };
-                const nameProp = AstParserService.findNameProperty(inner);
-                if (!nameProp)
-                    continue;
-                if (ts_morph_1.Node.isShorthandPropertyAssignment(nameProp))
-                    return { ok: false, reason: 'non-literal-name' };
-                const init = nameProp.getInitializer();
-                const value = init ? AstParserService.literalStringValue(init) : null;
-                if (value !== null)
-                    return AstParserService.checkGraphqlGrammar(value);
-                return { ok: false, reason: 'non-literal-name' };
-            }
-        }
-        return AstParserService.checkGraphqlGrammar(fallbackName);
-    }
-    logGraphqlSkip(filePath, declaration, decorator, reason, value) {
-        const fields = { filePath, declaration, decorator, reason };
-        if (value !== undefined)
-            fields.value = value;
-        this.logger.debug('AstParser: graphql row skipped', fields);
-    }
-    /** `declNode`'s qualified TypeScript name for diagnostics, independent of
-     * whether its own `code_symbol` row was actually written. */
-    declarationNameFor(node, fallback) {
-        const described = this.describeIndexedNode(node);
-        return described ? this.qualifiedName(described) : fallback;
-    }
-    /** The identifier named by a `@Resolver` argument: directly, or as an arrow
-     * function's expression body; or the sole identifier of a single-element
-     * array literal in either position (list-returning resolver). */
-    static extractResolverIdentifier(argNode) {
-        let target = argNode;
-        if (ts_morph_1.Node.isArrowFunction(target)) {
-            const body = target.getBody();
-            if (ts_morph_1.Node.isBlock(body))
-                return null;
-            target = body;
-        }
-        if (ts_morph_1.Node.isIdentifier(target))
-            return target;
-        if (ts_morph_1.Node.isArrayLiteralExpression(target)) {
-            const elements = target.getElements();
-            if (elements.length === 1 && ts_morph_1.Node.isIdentifier(elements[0]))
-                return elements[0];
-        }
-        return null;
-    }
-    defaultResolveDeclaration(identifier) {
-        const sym = identifier.getSymbol();
-        if (!sym)
-            return undefined;
-        const firstDecl = sym.getDeclarations()?.[0];
-        const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl) ? (sym.getAliasedSymbol() ?? sym) : sym;
-        return resolved.getDeclarations()?.[0];
-    }
-    /** The GraphQL type name of a `@ResolveField`'s resolved parent class
-     * (design decision 5, second half): its recognised `@ObjectType` (else
-     * `@InterfaceType`) decorator, or its class name when it carries no
-     * decorator spelled `ObjectType`/`InterfaceType` at all, recognised or not. */
-    classGraphqlTypeName(declClass) {
-        const declImportMap = this.buildGraphqlImportMap(declClass.getSourceFile());
-        const decorators = declClass.getDecorators();
-        const hasAnyTypeSpelledDecorator = decorators.some((d) => {
-            const idNode = AstParserService.decoratorIdentifier(d);
-            const text = idNode?.getText();
-            return text === 'ObjectType' || text === 'InterfaceType';
-        });
-        const recognized = decorators
-            .map(d => this.recognizedDecorator(d, declImportMap))
-            .find(r => r?.name === 'ObjectType')
-            ?? decorators.map(d => this.recognizedDecorator(d, declImportMap)).find(r => r?.name === 'InterfaceType');
-        if (recognized) {
-            const fallbackName = declClass.getName() ?? (declClass.isDefaultExport() ? 'default' : '');
-            const nameResult = this.deriveGraphqlName(recognized.args, false, fallbackName);
-            return nameResult.ok ? { ok: true, name: nameResult.name } : { ok: false };
-        }
-        // Carries a type-spelled decorator that isn't recognised (e.g. imported
-        // through a barrel) — its GraphQL name is unreadable; the class-name
-        // fallback never applies to it (it may differ from the unreadable name).
-        if (hasAnyTypeSpelledDecorator)
-            return { ok: false };
-        const name = declClass.getName();
-        if (!name)
-            return { ok: false };
-        return GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, value: name };
-    }
-    /** The parent type of a `@ResolveField` — the enclosing class's recognised
-     * `@Resolver` argument (design decision 5, first half). */
-    resolveResolverParentType(cls, importMap) {
-        const resolverDec = cls.getDecorators()
-            .map(d => this.recognizedDecorator(d, importMap))
-            .find(r => r?.name === 'Resolver');
-        if (!resolverDec || resolverDec.args.length === 0)
-            return { ok: false };
-        const argNode = resolverDec.args[0];
-        const literal = AstParserService.literalStringValue(argNode);
-        if (literal !== null) {
-            return GRAPHQL_NAME_RE.test(literal) ? { ok: true, name: literal } : { ok: false, value: literal };
-        }
-        const identifier = AstParserService.extractResolverIdentifier(argNode);
-        if (!identifier)
-            return { ok: false };
-        const resolve = this.deps.resolveDeclaration ?? this.defaultResolveDeclaration.bind(this);
-        const declaration = resolve(identifier);
-        if (!declaration || !ts_morph_1.Node.isClassDeclaration(declaration))
-            return { ok: false };
-        return this.classGraphqlTypeName(declaration);
-    }
-    extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries) {
-        const own = ownByDeclNode.get(cls);
-        const declaration = this.declarationNameFor(cls, own?.entry.name ?? cls.getName() ?? 'default');
-        const seenNames = new Set();
-        for (const dec of cls.getDecorators()) {
-            const rec = this.recognizedDecorator(dec, importMap);
-            if (!rec || !GRAPHQL_TYPE_DECORATORS.has(rec.name))
-                continue;
-            if (AstParserService.isAbstractGraphqlType(rec.args)) {
-                this.logGraphqlSkip(filePath, declaration, rec.name, 'abstract-type');
-                continue;
-            }
-            if (!own) {
-                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
-                continue;
-            }
-            const nameResult = this.deriveGraphqlName(rec.args, false, own.entry.name);
-            if (!nameResult.ok) {
-                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
-                continue;
-            }
-            if (seenNames.has(nameResult.name)) {
-                this.logGraphqlSkip(filePath, declaration, rec.name, 'duplicate', own.entry.name);
-                continue;
-            }
-            seenNames.add(nameResult.name);
-            entries.push({
-                project: serviceName, filePath, name: nameResult.name, kind: 'graphql_type',
-                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
-                container: null, isStatic: false, target: declaration,
-            });
-        }
-    }
-    extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries) {
-        if (!own) {
-            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'no-symbol-row');
-            return;
-        }
-        const cls = method.getParent();
-        if (!cls || !ts_morph_1.Node.isClassDeclaration(cls)) {
-            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
-            return;
-        }
-        const parent = this.resolveResolverParentType(cls, importMap);
-        if (!parent.ok) {
-            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent', parent.value);
-            return;
-        }
-        const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
-        if (!nameResult.ok) {
-            this.logGraphqlSkip(filePath, declaration, 'ResolveField', nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
-            return;
-        }
-        entries.push({
-            project: serviceName, filePath, name: nameResult.name, kind: 'graphql_field',
-            signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
-            container: parent.name, isStatic: own.entry.isStatic, target: declaration,
-        });
-    }
-    extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries) {
-        const own = ownByDeclNode.get(method);
-        const declaration = this.declarationNameFor(method, own?.entry.name ?? AstParserService.memberName(method.getNameNode()) ?? '<anonymous>');
-        for (const dec of method.getDecorators()) {
-            const rec = this.recognizedDecorator(dec, importMap);
-            if (!rec)
-                continue;
-            if (rec.name === 'ResolveField') {
-                // Isolated per field: a throw resolving this field's parent (e.g. the
-                // injected test seam) degrades to "no row for that field" and never
-                // trips the file-level catch in `analyzeSourceFile`.
-                try {
-                    this.extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries);
-                }
-                catch (err) {
-                    this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
-                }
-                continue;
-            }
-            const kind = GRAPHQL_OPERATION_KIND[rec.name];
-            if (!kind)
-                continue; // recognised but not an operation decorator (wrong declaration kind) — ignored, no log
-            if (!own) {
-                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
-                continue;
-            }
-            const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
-            if (!nameResult.ok) {
-                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
-                continue;
-            }
-            entries.push({
-                project: serviceName, filePath, name: nameResult.name, kind,
-                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
-                container: rec.name, isStatic: own.entry.isStatic, target: declaration,
-            });
-        }
-    }
-    /** GraphQL-named rows for every recognised `@nestjs/graphql` decorator in
-     * the file (`graphql-symbols`). `ownRows` is `symbols ∪ members` — the
-     * declarations' own `code_symbol` candidates, checked so a GraphQL row is
-     * never written without its decorated declaration's own row. */
-    extractGraphqlNames(sourceFile, filePath, serviceName, ownRows) {
-        const importMap = this.buildGraphqlImportMap(sourceFile);
-        if (importMap.size === 0)
-            return [];
-        const ownByDeclNode = new Map();
-        for (const c of ownRows)
-            ownByDeclNode.set(c.declNode, c);
-        const entries = [];
-        for (const cls of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration)) {
-            this.extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries);
-        }
-        for (const method of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
-            this.extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries);
-        }
-        return entries;
-    }
-    // ── private: shared container resolution ────────────────────────────────────
-    static isValidSegment(s) {
-        return VALID_SEGMENT.test(s);
-    }
-    static memberName(nameNode) {
-        if (!nameNode)
-            return null;
-        if (ts_morph_1.Node.isPrivateIdentifier(nameNode))
-            return nameNode.getText();
-        if (ts_morph_1.Node.isIdentifier(nameNode))
-            return nameNode.getText();
-        if (ts_morph_1.Node.isStringLiteral(nameNode))
-            return nameNode.getLiteralValue();
-        if (ts_morph_1.Node.isNumericLiteral(nameNode))
-            return nameNode.getText();
-        if (ts_morph_1.Node.isComputedPropertyName(nameNode))
-            return nameNode.getText().replace(/\s+/g, '');
-        return null;
-    }
-    static unwrapExpr(node) {
-        let current = node;
-        while (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current)) {
-            current = current.getExpression();
-        }
-        return current;
-    }
-    static unwrapParent(node) {
-        let current = node.getParent();
-        while (current && (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current))) {
-            current = current.getParent();
-        }
-        return current;
-    }
-    isModuleOrNamespaceLevelVariable(varDecl) {
-        // VariableDeclaration -> VariableDeclarationList -> VariableStatement -> (SourceFile | ModuleBlock)
-        const stmt = varDecl.getParent()?.getParent();
-        const stmtParent = stmt?.getParent();
-        return ts_morph_1.Node.isSourceFile(stmtParent) || ts_morph_1.Node.isModuleBlock(stmtParent);
-    }
-    classExpressionRoot(classExpr) {
-        const parent = AstParserService.unwrapParent(classExpr);
-        if (!parent)
-            return null;
-        if (ts_morph_1.Node.isVariableDeclaration(parent)) {
-            const name = parent.getName();
-            return name ? { name, namingParent: parent } : null;
-        }
-        if (ts_morph_1.Node.isExportAssignment(parent) && !parent.isExportEquals()) {
-            return { name: 'default', namingParent: parent };
-        }
-        return null;
-    }
-    objectLiteralRootValid(obj) {
-        const parent = AstParserService.unwrapParent(obj);
-        if (!parent)
-            return false;
-        if (ts_morph_1.Node.isPropertyAssignment(parent))
-            return true;
-        if (ts_morph_1.Node.isVariableDeclaration(parent))
-            return this.isModuleOrNamespaceLevelVariable(parent);
-        if (ts_morph_1.Node.isExportAssignment(parent) && !parent.isExportEquals())
-            return true;
-        return false;
-    }
-    isTopLevelOrNamespaceDirect(node) {
-        return ts_morph_1.Node.isSourceFile(node) || ts_morph_1.Node.isModuleBlock(node);
-    }
-    /** One step of the ancestor walk used by `containerSegments`: does `node`
-     * contribute a named segment, pass through transparently, or disqualify
-     * (exclude) everything nested inside it? */
-    walkStep(node) {
-        if (ts_morph_1.Node.isModuleDeclaration(node)) {
-            if (node.compilerNode.flags & ts_morph_1.NodeFlags.GlobalAugmentation)
-                return { kind: 'exclude' };
-            const nameNode = node.getNameNode();
-            if (ts_morph_1.Node.isStringLiteral(nameNode))
-                return { kind: 'exclude' };
-            return { kind: 'segment', text: nameNode.getText() };
-        }
-        if (ts_morph_1.Node.isClassDeclaration(node)) {
-            const name = node.getName();
-            if (name)
-                return { kind: 'segment', text: name };
-            if (node.isDefaultExport())
-                return { kind: 'segment', text: 'default' };
-            return { kind: 'exclude' };
-        }
-        if (ts_morph_1.Node.isClassExpression(node)) {
-            const root = this.classExpressionRoot(node);
-            if (!root)
-                return { kind: 'exclude' };
-            return { kind: 'segment', text: root.name, skipTo: root.namingParent };
-        }
-        if (ts_morph_1.Node.isFunctionDeclaration(node)) {
-            const name = node.getName();
-            return name ? { kind: 'segment', text: name } : { kind: 'transparent' };
-        }
-        if (ts_morph_1.Node.isMethodDeclaration(node) || ts_morph_1.Node.isGetAccessorDeclaration(node) || ts_morph_1.Node.isSetAccessorDeclaration(node)) {
-            const name = AstParserService.memberName(node.getNameNode());
-            return name !== null ? { kind: 'segment', text: name } : { kind: 'exclude' };
-        }
-        if (ts_morph_1.Node.isConstructorDeclaration(node)) {
-            return { kind: 'segment', text: 'constructor' };
-        }
-        if (ts_morph_1.Node.isPropertyDeclaration(node) || ts_morph_1.Node.isPropertyAssignment(node)) {
-            const name = AstParserService.memberName(node.getNameNode());
-            return name !== null ? { kind: 'segment', text: name } : { kind: 'exclude' };
-        }
-        if (ts_morph_1.Node.isInterfaceDeclaration(node)) {
-            return { kind: 'segment', text: node.getName() };
-        }
-        if (ts_morph_1.Node.isTypeAliasDeclaration(node)) {
-            return { kind: 'segment', text: node.getName() };
-        }
-        if (ts_morph_1.Node.isVariableDeclaration(node)) {
-            return { kind: 'segment', text: node.getName() };
-        }
-        if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
-            return this.objectLiteralRootValid(node) ? { kind: 'transparent' } : { kind: 'exclude' };
-        }
-        return { kind: 'transparent' };
-    }
-    /** The dotted container path of `node`'s enclosing named scopes, outermost
-     * first, or null when any contributing ancestor is invalid (a computed /
-     * string-literal segment, a string-named module, `declare global`, or an
-     * unrooted class expression / object literal). */
-    containerSegments(node) {
-        const segments = [];
-        let current = node.getParent();
-        while (current) {
-            const step = this.walkStep(current);
-            if (step.kind === 'exclude')
-                return null;
-            if (step.kind === 'segment') {
-                if (!AstParserService.isValidSegment(step.text))
-                    return null;
-                segments.unshift(step.text);
-                current = step.skipTo ? step.skipTo.getParent() : current.getParent();
-                continue;
-            }
-            current = current.getParent();
-        }
-        return segments;
-    }
-    /** If `node` is a declaration this service indexes (top-level symbol, member,
-     * or collected class), its own name + container. Otherwise null. Shared by
-     * member extraction, ownership ranges and the call graph so all three name a
-     * declaration identically. */
-    describeIndexedNode(node) {
-        if (ts_morph_1.Node.isClassDeclaration(node)) {
-            const name = node.getName() ?? (node.isDefaultExport() ? 'default' : null);
-            if (name === null)
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name, container };
-        }
-        if (ts_morph_1.Node.isClassExpression(node)) {
-            const root = this.classExpressionRoot(node);
-            if (!root)
-                return null;
-            const container = this.containerSegments(root.namingParent);
-            return container === null ? null : { name: root.name, container };
-        }
-        if (ts_morph_1.Node.isFunctionDeclaration(node)) {
-            const name = node.getName();
-            if (!name || !this.isTopLevelOrNamespaceDirect(node.getParent()))
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name, container };
-        }
-        if (ts_morph_1.Node.isMethodDeclaration(node) || ts_morph_1.Node.isGetAccessorDeclaration(node) || ts_morph_1.Node.isSetAccessorDeclaration(node)) {
-            const name = AstParserService.memberName(node.getNameNode());
-            if (name === null)
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name, container };
-        }
-        if (ts_morph_1.Node.isConstructorDeclaration(node)) {
-            const container = this.containerSegments(node);
-            return container === null ? null : { name: 'constructor', container };
-        }
-        if (ts_morph_1.Node.isPropertyDeclaration(node) || ts_morph_1.Node.isPropertyAssignment(node)) {
-            const init = node.getInitializer();
-            if (!init)
-                return null;
-            const unwrapped = AstParserService.unwrapExpr(init);
-            if (!(ts_morph_1.Node.isArrowFunction(unwrapped) || ts_morph_1.Node.isFunctionExpression(unwrapped)))
-                return null;
-            const name = AstParserService.memberName(node.getNameNode());
-            if (name === null)
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name, container };
-        }
-        if (ts_morph_1.Node.isInterfaceDeclaration(node)) {
-            if (!this.isTopLevelOrNamespaceDirect(node.getParent()))
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name: node.getName(), container };
-        }
-        if (ts_morph_1.Node.isTypeAliasDeclaration(node)) {
-            if (!this.isTopLevelOrNamespaceDirect(node.getParent()))
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name: node.getName(), container };
-        }
-        if (ts_morph_1.Node.isVariableDeclaration(node)) {
-            if (!this.isModuleOrNamespaceLevelVariable(node))
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name: node.getName(), container };
-        }
-        if (ts_morph_1.Node.isMethodSignature(node) || ts_morph_1.Node.isPropertySignature(node)) {
-            if (ts_morph_1.Node.isPropertySignature(node)) {
-                const typeNode = node.getTypeNode();
-                if (!typeNode || !ts_morph_1.Node.isFunctionTypeNode(typeNode))
-                    return null;
-            }
-            const parent = node.getParent();
-            let validParent = false;
-            if (ts_morph_1.Node.isInterfaceDeclaration(parent)) {
-                validParent = true;
-            }
-            else if (ts_morph_1.Node.isTypeLiteral(parent)) {
-                const aliasParent = parent.getParent();
-                validParent = ts_morph_1.Node.isTypeAliasDeclaration(aliasParent) && aliasParent.getTypeNode() === parent;
-            }
-            if (!validParent)
-                return null;
-            const name = AstParserService.memberName(node.getNameNode());
-            if (name === null)
-                return null;
-            const container = this.containerSegments(node);
-            return container === null ? null : { name, container };
-        }
-        return null;
-    }
-    qualifiedName(described) {
-        return described.container.length ? `${described.container.join('.')}.${described.name}` : described.name;
-    }
-    /** The qualified name of the nearest ancestor of `node` that is itself an
-     * indexed declaration (method, accessor, constructor, function property,
-     * namespace/top-level function, or module-/namespace-level variable). */
-    findFromSymbol(node) {
-        let current = node.getParent();
-        while (current) {
-            const described = this.describeIndexedNode(current);
-            if (described)
-                return this.qualifiedName(described);
-            current = current.getParent();
+    buildDeclarations(sourceFile, filePath, symbolCandidates, memberCandidates) {
+        try {
+            return this.declarationBuilder.build(sourceFile, [...symbolCandidates, ...memberCandidates]);
         }
-        return null;
-    }
-    // ── private: call graph extraction ────────────────────────────────────────
-    extractCalls(sourceFile, filePath, serviceName) {
-        const calls = [];
-        for (const callExpr of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
-            const expr = callExpr.getExpression();
-            let calleeName = null;
-            let calleeFile = null;
-            let calleeDecl;
+        catch (err) {
+            this.logger.warn('AstParser: declaration tree build failed', { filePath, err });
             try {
-                if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
-                    calleeName = expr.getName();
-                    const sym = expr.getNameNode().getSymbol();
-                    const decl = sym?.getDeclarations()?.[0];
-                    const declPath = decl?.getSourceFile().getFilePath();
-                    if (declPath && !declPath.includes('/node_modules/')) {
-                        calleeFile = declPath;
-                        calleeDecl = decl;
-                    }
-                }
-                else if (ts_morph_1.Node.isIdentifier(expr)) {
-                    calleeName = expr.getText();
-                    const sym = expr.getSymbol();
-                    if (sym) {
-                        // Imported identifiers resolve to ImportSpecifier (same file); follow the alias.
-                        const firstDecl = sym.getDeclarations()?.[0];
-                        const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl)
-                            ? (sym.getAliasedSymbol() ?? sym)
-                            : sym;
-                        const decl = resolved.getDeclarations()?.[0];
-                        const declPath = decl?.getSourceFile().getFilePath();
-                        if (declPath && !declPath.includes('/node_modules/')) {
-                            calleeFile = declPath;
-                            calleeDecl = decl;
-                        }
-                    }
-                }
+                return this.declarationBuilder.flat(symbolCandidates);
             }
             catch {
-                // type resolution failures are normal — skip this call
+                return DeclarationTree_1.DeclarationTree.EMPTY;
             }
-            if (!calleeName || !calleeFile)
-                continue;
-            const described = calleeDecl ? this.describeIndexedNode(calleeDecl) : null;
-            const calleeSymbol = described ? this.qualifiedName(described) : null;
-            const fromSymbol = this.findFromSymbol(callExpr);
-            const pos = sourceFile.compilerNode
-                .getLineAndCharacterOfPosition(callExpr.getStart());
-            calls.push({
-                project: serviceName,
-                fromFile: filePath,
-                fromSymbol,
-                calleeName,
-                calleeFile,
-                calleeSymbol,
-                line: pos.line + 1,
-                col: pos.character + 1,
-            });
         }
-        return calls;
     }
 }
 exports.AstParserService = AstParserService;