@optave/codegraph 3.4.0 → 3.5.0

package/src/domain/graph/resolve.ts

@@ -1,13 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { debug } from '../../infrastructure/logger.js';
 import { loadNative } from '../../infrastructure/native.js';
 import { normalizePath } from '../../shared/constants.js';
+import { toErrorMessage } from '../../shared/errors.js';
 import type { BareSpecifier, BatchResolvedMap, ImportBatchItem, PathAliases } from '../../types.js';
 
 // ── package.json exports resolution ─────────────────────────────────
 
 /** Cache: packageDir → parsed exports field (or null) */
-// biome-ignore lint/suspicious/noExplicitAny: package.json exports field has no fixed schema
 const _exportsCache: Map<string, any> = new Map();
 
 /**
@@ -55,7 +56,6 @@ function findPackageDir(packageName: string, rootDir: string): string | null {
  * Read and cache the exports field from a package's package.json.
  * Returns the exports value or null.
  */
-// biome-ignore lint/suspicious/noExplicitAny: package.json exports field has no fixed schema
 function getPackageExports(packageDir: string): any {
   if (_exportsCache.has(packageDir)) return _exportsCache.get(packageDir);
   try {
@@ -64,7 +64,8 @@ function getPackageExports(packageDir: string): any {
     const exports = pkg.exports ?? null;
     _exportsCache.set(packageDir, exports);
     return exports;
-  } catch {
+  } catch (e) {
+    debug(`readPackageExports: failed to read package.json in ${packageDir}: ${toErrorMessage(e)}`);
     _exportsCache.set(packageDir, null);
     return null;
   }
@@ -515,8 +516,10 @@ export function resolveImportPath(
       // unresolved ".." components (PathBuf::components().collect() doesn't
       // collapse parent refs). Apply the remap on the JS side as a fallback.
       return remapJsToTs(normalized, rootDir);
-    } catch {
-      // fall through to JS
+    } catch (e) {
+      debug(
+        `resolveImportPath: native resolution failed, falling back to JS: ${toErrorMessage(e)}`,
+      );
     }
   }
   return resolveImportPathJS(fromFile, importSource, rootDir, aliases);
@@ -535,8 +538,10 @@ export function computeConfidence(
   if (native) {
     try {
       return native.computeConfidence(callerFile, targetFile, importedFrom || null);
-    } catch {
-      // fall through to JS
+    } catch (e) {
+      debug(
+        `computeConfidence: native computation failed, falling back to JS: ${toErrorMessage(e)}`,
+      );
     }
   }
   return computeConfidenceJS(callerFile, targetFile, importedFrom);
@@ -575,7 +580,8 @@ export function resolveImportsBatch(
       map.set(`${r.fromFile}|${r.importSource}`, resolved);
     }
     return map;
-  } catch {
+  } catch (e) {
+    debug(`batchResolve: native batch resolution failed: ${toErrorMessage(e)}`);
     return null;
   }
 }

package/src/domain/graph/watcher.ts

@@ -24,9 +24,7 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     throw new DbError('No graph.db found. Run `codegraph build` first.', { file: dbPath });
   }
 
-  const db = openDb(dbPath) as import('better-sqlite3').Database;
-  // Alias for functions expecting the project's BetterSqlite3Database interface
-  const typedDb = db as unknown as import('../../types.js').BetterSqlite3Database;
+  const db = openDb(dbPath);
   initSchema(db);
   const engineOpts: import('../../types.js').EngineOpts = {
     engine: (opts.engine || 'auto') as import('../../types.js').EngineMode,
@@ -51,7 +49,7 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     ),
     getNodeId: {
       get: (name: string, kind: string, file: string, line: number) => {
-        const id = getNodeIdQuery(typedDb, name, kind, file, line);
+        const id = getNodeIdQuery(db, name, kind, file, line);
         return id != null ? { id } : undefined;
       },
     },

package/src/domain/parser.ts

@@ -5,6 +5,7 @@ import type { Tree } from 'web-tree-sitter';
 import { Language, Parser, Query } from 'web-tree-sitter';
 import { debug, warn } from '../infrastructure/logger.js';
 import { getNative, getNativePackageVersion, loadNative } from '../infrastructure/native.js';
+import { toErrorMessage } from '../shared/errors.js';
 import type {
   EngineMode,
   ExtractorOutput,
@@ -69,7 +70,6 @@ interface ParseEngineOpts {
 
 interface ResolvedEngine {
   name: 'native' | 'wasm';
-  // biome-ignore lint/suspicious/noExplicitAny: native addon has no type declarations
   native: any;
 }
 
@@ -85,6 +85,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(variable_declarator name: (identifier) @varfn_name value: (arrow_function) @varfn_value)',
   '(variable_declarator name: (identifier) @varfn_name value: (function_expression) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
@@ -171,7 +172,6 @@ export function disposeParsers(): void {
   _queryCache.clear();
   if (_cachedLanguages) {
     for (const [id, lang] of _cachedLanguages) {
-      // biome-ignore lint/suspicious/noExplicitAny: .delete() exists at runtime on WASM Language objects but is missing from typings
       if (lang && typeof (lang as any).delete === 'function') {
         try {
           (lang as any).delete();
@@ -197,7 +197,6 @@ export function getParser(parsers: Map<string, Parser | null>, filePath: string)
  * don't each need to create parsers and re-parse independently.
  * Only parses files whose extension is in SUPPORTED_EXTENSIONS.
  */
-// biome-ignore lint/suspicious/noExplicitAny: fileSymbols values have dynamic shape from extractors
 export async function ensureWasmTrees(
   fileSymbols: Map<string, any>,
   rootDir: string,
@@ -274,7 +273,6 @@ function resolveEngine(opts: ParseEngineOpts = {}): ResolvedEngine {
  *  - Backward compat for older native binaries missing js_name annotations
  *  - dataflow argFlows/mutations bindingType -> binding wrapper
  */
-// biome-ignore lint/suspicious/noExplicitAny: native addon result has no type declarations
 function patchNativeResult(r: any): ExtractorOutput {
   // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
   r.lineCount = r.lineCount ?? r.line_count ?? null;
@@ -433,7 +431,6 @@ export const SUPPORTED_EXTENSIONS: Set<string> = new Set(_extToLang.keys());
  * matches inside comments and string literals.
  * TODO: Remove once all published native binaries include typeMap extraction (>= 3.2.0)
  */
-// biome-ignore lint/suspicious/noExplicitAny: return shape matches native result typeMap
 async function backfillTypeMap(
   filePath: string,
   source?: string,
@@ -442,7 +439,8 @@ async function backfillTypeMap(
   if (!code) {
     try {
       code = fs.readFileSync(filePath, 'utf-8');
-    } catch {
+    } catch (e) {
+      debug(`backfillTypeMap: failed to read ${filePath}: ${toErrorMessage(e)}`);
       return { typeMap: new Map(), backfilled: false };
     }
   }
@@ -458,7 +456,9 @@ async function backfillTypeMap(
     if (extracted?.tree && typeof extracted.tree.delete === 'function') {
       try {
         extracted.tree.delete();
-      } catch {}
+      } catch (e) {
+        debug(`backfillTypeMap: WASM tree cleanup failed: ${toErrorMessage(e)}`);
+      }
     }
   }
 }
@@ -488,7 +488,6 @@ function wasmExtractSymbols(
   if (!entry) return null;
   const query = _queryCache.get(entry.id) ?? undefined;
   // Query (web-tree-sitter) is structurally compatible with TreeSitterQuery at runtime
-  // biome-ignore lint/suspicious/noExplicitAny: thin WASM wrapper type mismatch
   const symbols = entry.extractor(tree as any, filePath, query as any);
   return symbols ? { symbols, tree, langId: entry.id } : null;
 }
@@ -571,14 +570,16 @@ export async function parseFilesAuto(
               symbols.typeMap = extracted.symbols.typeMap;
               symbols._typeMapBackfilled = true;
             }
-          } catch {
-            /* skip — typeMap is a best-effort backfill */
+          } catch (e) {
+            debug(`batchExtract: typeMap backfill failed: ${toErrorMessage(e)}`);
           } finally {
             // Free the WASM tree to prevent memory accumulation across repeated builds
             if (extracted?.tree && typeof extracted.tree.delete === 'function') {
               try {
                 extracted.tree.delete();
-              } catch {}
+              } catch (e) {
+                debug(`batchExtract: WASM tree cleanup failed: ${toErrorMessage(e)}`);
+              }
             }
           }
         }
@@ -638,7 +639,6 @@ export function getActiveEngine(opts: ParseEngineOpts = {}): {
  * Create a native ParseTreeCache for incremental parsing.
  * Returns null if the native engine is unavailable (WASM fallback).
  */
-// biome-ignore lint/suspicious/noExplicitAny: native ParseTreeCache has no type declarations
 export function createParseTreeCache(): any {
   const native = loadNative();
   if (!native || !native.ParseTreeCache) return null;
@@ -648,7 +648,6 @@ export function createParseTreeCache(): any {
 /**
  * Parse a file incrementally using the cache, or fall back to full parse.
  */
-// biome-ignore lint/suspicious/noExplicitAny: cache is native ParseTreeCache with no type declarations
 export async function parseFileIncremental(
   cache: any,
   filePath: string,

package/src/domain/queries.ts

@@ -8,6 +8,7 @@
 
 // ── Re-export from dedicated module for backward compat ───────────────────
 export { isTestFile, TEST_PATTERN } from '../infrastructure/test-filter.js';
+export { diffImpactMermaid } from '../presentation/diff-impact-mermaid.js';
 export { iterListFunctions, iterRoles, iterWhere } from '../shared/generators.js';
 // ── Kind/edge constants (canonical source: kinds.js) ─────────────────────
 export {
@@ -24,11 +25,10 @@ export {
 export { kindIcon, normalizeSymbol } from '../shared/normalize.js';
 export { briefData } from './analysis/brief.js';
 export { contextData, explainData } from './analysis/context.js';
-export { fileDepsData, fnDepsData, pathData } from './analysis/dependencies.js';
+export { fileDepsData, filePathData, fnDepsData, pathData } from './analysis/dependencies.js';
 export { exportsData } from './analysis/exports.js';
 export {
   diffImpactData,
-  diffImpactMermaid,
   fnImpactData,
   impactAnalysisData,
 } from './analysis/impact.js';

package/src/domain/search/generator.ts

@@ -1,10 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import type BetterSqlite3 from 'better-sqlite3';
 import { closeDb, findDbPath, openDb } from '../../db/index.js';
 import { warn } from '../../infrastructure/logger.js';
 import { DbError } from '../../shared/errors.js';
-import type { NodeRow } from '../../types.js';
+import type { BetterSqlite3Database, NodeRow } from '../../types.js';
 import { embed, getModelConfig } from './models.js';
 import { buildSourceText } from './strategies/source.js';
 import { buildStructuredText } from './strategies/structured.js';
@@ -17,7 +16,7 @@ export function estimateTokens(text: string): number {
   return Math.ceil(text.length / 4);
 }
 
-function initEmbeddingsSchema(db: BetterSqlite3.Database): void {
+function initEmbeddingsSchema(db: BetterSqlite3Database): void {
   db.exec(`
     CREATE TABLE IF NOT EXISTS embeddings (
       node_id INTEGER PRIMARY KEY,
@@ -71,7 +70,7 @@ export async function buildEmbeddings(
     );
   }
 
-  const db = openDb(dbPath) as BetterSqlite3.Database;
+  const db = openDb(dbPath) as BetterSqlite3Database;
   initEmbeddingsSchema(db);
 
   db.exec('DELETE FROM embeddings');

package/src/extractors/csharp.ts

@@ -6,7 +6,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from C# files.
@@ -333,7 +333,7 @@ function extractCSharpTypeMapDepth(
   ctx: ExtractorOutput,
   depth: number,
 ): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // local_declaration_statement → variable_declaration → type + variable_declarator(s)
   if (node.type === 'variable_declaration') {

package/src/extractors/go.ts

@@ -6,7 +6,7 @@ import type {
   TreeSitterTree,
   TypeMapEntry,
 } from '../types.js';
-import { findChild, goVisibility, nodeEndLine } from './helpers.js';
+import { findChild, goVisibility, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Go files.
@@ -233,7 +233,7 @@ function setIfHigher(
 }
 
 function extractGoTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // var x MyType = ... or var x, y MyType → var_declaration > var_spec (confidence 0.9)
   if (node.type === 'var_spec') {

package/src/extractors/helpers.ts

@@ -1,5 +1,11 @@
 import type { TreeSitterNode } from '../types.js';
 
+/**
+ * Maximum recursion depth for tree-sitter AST walkers.
+ * Shared across all language extractors to prevent stack overflow on deeply nested ASTs.
+ */
+export const MAX_WALK_DEPTH = 200;
+
 export function nodeEndLine(node: TreeSitterNode): number {
   return node.endPosition.row + 1;
 }

package/src/extractors/javascript.ts

@@ -12,7 +12,7 @@ import type {
   TreeSitterTree,
   TypeMapEntry,
 } from '../types.js';
-import { findChild, nodeEndLine } from './helpers.js';
+import { findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 /** Built-in globals that start with uppercase but are not user-defined types. */
 const BUILTIN_GLOBALS: Set<string> = new Set([
@@ -102,44 +102,42 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
     const c: Record<string, TreeSitterNode> = Object.create(null);
     for (const cap of match.captures) c[cap.name] = cap.node;
 
-    if (c['fn_node']) {
+    if (c.fn_node) {
       // function_declaration
-      const fnChildren = extractParameters(c['fn_node']);
+      const fnChildren = extractParameters(c.fn_node);
       definitions.push({
-        name: c['fn_name']!.text,
+        name: c.fn_name!.text,
         kind: 'function',
-        line: c['fn_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['fn_node']),
+        line: c.fn_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.fn_node),
         children: fnChildren.length > 0 ? fnChildren : undefined,
       });
-    } else if (c['varfn_name']) {
+    } else if (c.varfn_name) {
       // variable_declarator with arrow_function / function_expression
-      const declNode = c['varfn_name'].parent?.parent;
-      const line = declNode
-        ? declNode.startPosition.row + 1
-        : c['varfn_name'].startPosition.row + 1;
-      const varFnChildren = extractParameters(c['varfn_value']!);
+      const declNode = c.varfn_name.parent?.parent;
+      const line = declNode ? declNode.startPosition.row + 1 : c.varfn_name.startPosition.row + 1;
+      const varFnChildren = extractParameters(c.varfn_value!);
       definitions.push({
-        name: c['varfn_name'].text,
+        name: c.varfn_name.text,
         kind: 'function',
         line,
-        endLine: nodeEndLine(c['varfn_value']!),
+        endLine: nodeEndLine(c.varfn_value!),
         children: varFnChildren.length > 0 ? varFnChildren : undefined,
       });
-    } else if (c['cls_node']) {
+    } else if (c.cls_node) {
       // class_declaration
-      const className = c['cls_name']!.text;
-      const startLine = c['cls_node'].startPosition.row + 1;
-      const clsChildren = extractClassProperties(c['cls_node']);
+      const className = c.cls_name!.text;
+      const startLine = c.cls_node.startPosition.row + 1;
+      const clsChildren = extractClassProperties(c.cls_node);
       definitions.push({
         name: className,
         kind: 'class',
         line: startLine,
-        endLine: nodeEndLine(c['cls_node']),
+        endLine: nodeEndLine(c.cls_node),
         children: clsChildren.length > 0 ? clsChildren : undefined,
       });
       const heritage =
-        c['cls_node'].childForFieldName('heritage') || findChild(c['cls_node'], 'class_heritage');
+        c.cls_node.childForFieldName('heritage') || findChild(c.cls_node, 'class_heritage');
       if (heritage) {
         const superName = extractSuperclass(heritage);
         if (superName) classes.push({ name: className, extends: superName, line: startLine });
@@ -148,58 +146,58 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
           classes.push({ name: className, implements: iface, line: startLine });
         }
       }
-    } else if (c['meth_node']) {
+    } else if (c.meth_node) {
       // method_definition
-      const methName = c['meth_name']!.text;
-      const parentClass = findParentClass(c['meth_node']);
+      const methName = c.meth_name!.text;
+      const parentClass = findParentClass(c.meth_node);
       const fullName = parentClass ? `${parentClass}.${methName}` : methName;
-      const methChildren = extractParameters(c['meth_node']);
-      const methVis = extractVisibility(c['meth_node']);
+      const methChildren = extractParameters(c.meth_node);
+      const methVis = extractVisibility(c.meth_node);
       definitions.push({
         name: fullName,
         kind: 'method',
-        line: c['meth_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['meth_node']),
+        line: c.meth_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.meth_node),
         children: methChildren.length > 0 ? methChildren : undefined,
         visibility: methVis,
       });
-    } else if (c['iface_node']) {
+    } else if (c.iface_node) {
       // interface_declaration (TS/TSX only)
-      const ifaceName = c['iface_name']!.text;
+      const ifaceName = c.iface_name!.text;
       definitions.push({
         name: ifaceName,
         kind: 'interface',
-        line: c['iface_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['iface_node']),
+        line: c.iface_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.iface_node),
       });
       const body =
-        c['iface_node'].childForFieldName('body') ||
-        findChild(c['iface_node'], 'interface_body') ||
-        findChild(c['iface_node'], 'object_type');
+        c.iface_node.childForFieldName('body') ||
+        findChild(c.iface_node, 'interface_body') ||
+        findChild(c.iface_node, 'object_type');
       if (body) extractInterfaceMethods(body, ifaceName, definitions);
-    } else if (c['type_node']) {
+    } else if (c.type_node) {
       // type_alias_declaration (TS/TSX only)
       definitions.push({
-        name: c['type_name']!.text,
+        name: c.type_name!.text,
         kind: 'type',
-        line: c['type_node'].startPosition.row + 1,
-        endLine: nodeEndLine(c['type_node']),
+        line: c.type_node.startPosition.row + 1,
+        endLine: nodeEndLine(c.type_node),
       });
-    } else if (c['imp_node']) {
+    } else if (c.imp_node) {
       // import_statement
-      const isTypeOnly = c['imp_node'].text.startsWith('import type');
-      const modPath = c['imp_source']!.text.replace(/['"]/g, '');
-      const names = extractImportNames(c['imp_node']);
+      const isTypeOnly = c.imp_node.text.startsWith('import type');
+      const modPath = c.imp_source!.text.replace(/['"]/g, '');
+      const names = extractImportNames(c.imp_node);
       imports.push({
         source: modPath,
         names,
-        line: c['imp_node'].startPosition.row + 1,
+        line: c.imp_node.startPosition.row + 1,
         typeOnly: isTypeOnly,
       });
-    } else if (c['exp_node']) {
+    } else if (c.exp_node) {
       // export_statement
-      const exportLine = c['exp_node'].startPosition.row + 1;
-      const decl = c['exp_node'].childForFieldName('declaration');
+      const exportLine = c.exp_node.startPosition.row + 1;
+      const decl = c.exp_node.childForFieldName('declaration');
       if (decl) {
         const declType = decl.type;
         const kindMap: Record<string, string> = {
@@ -214,12 +212,11 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
           if (n) exps.push({ name: n.text, kind: kind as Export['kind'], line: exportLine });
         }
       }
-      const source =
-        c['exp_node'].childForFieldName('source') || findChild(c['exp_node'], 'string');
+      const source = c.exp_node.childForFieldName('source') || findChild(c.exp_node, 'string');
       if (source && !decl) {
         const modPath = source.text.replace(/['"]/g, '');
-        const reexportNames = extractImportNames(c['exp_node']);
-        const nodeText = c['exp_node'].text;
+        const reexportNames = extractImportNames(c.exp_node);
+        const nodeText = c.exp_node.text;
         const isWildcard = nodeText.includes('export *') || nodeText.includes('export*');
         imports.push({
           source: modPath,
@@ -229,25 +226,25 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
           wildcardReexport: isWildcard && reexportNames.length === 0,
         });
       }
-    } else if (c['callfn_node']) {
+    } else if (c.callfn_node) {
       // call_expression with identifier function
       calls.push({
-        name: c['callfn_name']!.text,
-        line: c['callfn_node'].startPosition.row + 1,
+        name: c.callfn_name!.text,
+        line: c.callfn_node.startPosition.row + 1,
       });
-    } else if (c['callmem_node']) {
+    } else if (c.callmem_node) {
       // call_expression with member_expression function
-      const callInfo = extractCallInfo(c['callmem_fn']!, c['callmem_node']);
+      const callInfo = extractCallInfo(c.callmem_fn!, c.callmem_node);
       if (callInfo) calls.push(callInfo);
-      const cbDef = extractCallbackDefinition(c['callmem_node'], c['callmem_fn']);
+      const cbDef = extractCallbackDefinition(c.callmem_node, c.callmem_fn);
       if (cbDef) definitions.push(cbDef);
-    } else if (c['callsub_node']) {
+    } else if (c.callsub_node) {
       // call_expression with subscript_expression function
-      const callInfo = extractCallInfo(c['callsub_fn']!, c['callsub_node']);
+      const callInfo = extractCallInfo(c.callsub_fn!, c.callsub_node);
       if (callInfo) calls.push(callInfo);
-    } else if (c['assign_node']) {
+    } else if (c.assign_node) {
       // CommonJS: module.exports = require(...) / module.exports = { ...require(...) }
-      handleCommonJSAssignment(c['assign_left']!, c['assign_right']!, c['assign_node'], imports);
+      handleCommonJSAssignment(c.assign_left!, c.assign_right!, c.assign_node, imports);
     }
   }
 
@@ -263,51 +260,69 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
   return { definitions, calls, imports, classes, exports: exps, typeMap };
 }
 
+/** Node types that define a function scope — constants inside these are skipped. */
+const FUNCTION_SCOPE_TYPES = new Set([
+  'function_declaration',
+  'arrow_function',
+  'function_expression',
+  'method_definition',
+  'generator_function_declaration',
+  'generator_function',
+]);
+
 /**
- * Walk program-level children to extract `const x = <literal>` as constants.
- * The query-based fast path has no pattern for lexical_declaration/variable_declaration,
- * so constants are missed. This targeted walk fills that gap without a full tree traversal.
+ * Recursively walk the AST to extract `const x = <literal>` as constants.
+ * Skips nodes inside function scopes so only file-level / block-level constants
+ * are captured — matching the native engine's behaviour.
  */
-function extractConstantsWalk(rootNode: TreeSitterNode, definitions: Definition[]): void {
-  for (let i = 0; i < rootNode.childCount; i++) {
-    const node = rootNode.child(i);
-    if (!node) continue;
+function extractConstantsWalk(node: TreeSitterNode, definitions: Definition[]): void {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+
+    // Don't descend into function scopes
+    if (FUNCTION_SCOPE_TYPES.has(child.type)) continue;
 
-    let declNode = node;
+    let declNode = child;
     // Handle `export const …` — unwrap the export_statement to its declaration child
-    if (node.type === 'export_statement') {
-      const inner = node.childForFieldName('declaration');
-      if (!inner) continue;
-      declNode = inner;
+    if (child.type === 'export_statement') {
+      const inner = child.childForFieldName('declaration');
+      if (inner) declNode = inner;
     }
 
     const t = declNode.type;
-    if (t !== 'lexical_declaration' && t !== 'variable_declaration') continue;
-    if (!declNode.text.startsWith('const ')) continue;
-
-    for (let j = 0; j < declNode.childCount; j++) {
-      const declarator = declNode.child(j);
-      if (!declarator || declarator.type !== 'variable_declarator') continue;
-      const nameN = declarator.childForFieldName('name');
-      const valueN = declarator.childForFieldName('value');
-      if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
-      // Skip functions — already captured by query patterns
-      const valType = valueN.type;
-      if (
-        valType === 'arrow_function' ||
-        valType === 'function_expression' ||
-        valType === 'function'
-      )
-        continue;
-      if (isConstantValue(valueN)) {
-        definitions.push({
-          name: nameN.text,
-          kind: 'constant',
-          line: declNode.startPosition.row + 1,
-          endLine: nodeEndLine(declNode),
-        });
+    if (t === 'lexical_declaration' || t === 'variable_declaration') {
+      if (declNode.text.startsWith('const ')) {
+        for (let j = 0; j < declNode.childCount; j++) {
+          const declarator = declNode.child(j);
+          if (!declarator || declarator.type !== 'variable_declarator') continue;
+          const nameN = declarator.childForFieldName('name');
+          const valueN = declarator.childForFieldName('value');
+          if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
+          // Skip functions — already captured by query patterns
+          const valType = valueN.type;
+          if (
+            valType === 'arrow_function' ||
+            valType === 'function_expression' ||
+            valType === 'function'
+          )
+            continue;
+          if (isConstantValue(valueN)) {
+            definitions.push({
+              name: nameN.text,
+              kind: 'constant',
+              line: declNode.startPosition.row + 1,
+              endLine: nodeEndLine(declNode),
+            });
+          }
+        }
       }
     }
+
+    // Recurse into non-function, non-export-statement children (blocks, if-statements, etc.)
+    if (child.type !== 'export_statement') {
+      extractConstantsWalk(child, definitions);
+    }
   }
 }
 
@@ -929,7 +944,7 @@ function extractTypeMapWalk(rootNode: TreeSitterNode, typeMap: Map<string, TypeM
   }
 
   function walk(node: TreeSitterNode, depth: number): void {
-    if (depth >= 200) return;
+    if (depth >= MAX_WALK_DEPTH) return;
     const t = node.type;
     if (t === 'variable_declarator') {
       const nameN = node.childForFieldName('name');

package/src/extractors/php.ts

@@ -5,7 +5,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
 
 function extractPhpParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   const params: SubDeclaration[] = [];
@@ -340,7 +340,7 @@ function extractPhpTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function extractPhpTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // Function/method parameters with type hints
   if (