scip-query 0.5.0 → 0.6.1

package/dist/chunk-OMCRXXDX.js

@@ -1,2600 +0,0 @@
-import {
-  isFunctionLikeSymbol,
-  isModuleLikeSymbol,
-  leafName,
-  leafSuffix,
-  parseSymbol,
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/source-analysis.ts
-import {
-  existsSync,
-  readFileSync
-} from "fs";
-import {
-  basename,
-  dirname,
-  extname,
-  join,
-  relative,
-  resolve
-} from "path";
-var SOURCE_IMPORT_CACHE = /* @__PURE__ */ new WeakMap();
-var SOURCE_EXPORT_CACHE = /* @__PURE__ */ new WeakMap();
-var SOURCE_TEXT_CACHE = /* @__PURE__ */ new WeakMap();
-var SOURCE_CALL_CACHE = /* @__PURE__ */ new WeakMap();
-var SOURCE_BINDING_CACHE = /* @__PURE__ */ new WeakMap();
-var INDEXED_PATH_CACHE = /* @__PURE__ */ new WeakMap();
-var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-var PYTHON_SOURCE_EXTENSIONS = [".py", ".pyi"];
-var JVM_SOURCE_EXTENSIONS = [".java", ".scala", ".kt", ".kts"];
-var RUST_SOURCE_EXTENSIONS = [".rs"];
-var RUBY_SOURCE_EXTENSIONS = [".rb"];
-var C_LIKE_SOURCE_EXTENSIONS = [".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"];
-var DOTNET_SOURCE_EXTENSIONS = [".cs", ".vb"];
-var DART_SOURCE_EXTENSIONS = [".dart"];
-var PHP_SOURCE_EXTENSIONS = [".php"];
-function getSourceImports(db, relativePath) {
-  const cache = getCachedMap(SOURCE_IMPORT_CACHE, db);
-  const normalized = normalizePath(relativePath);
-  const cached = cache.get(normalized);
-  if (cached) {
-    return cached;
-  }
-  const fullPath = join(db.config.projectRoot, normalized);
-  if (!existsSync(fullPath)) {
-    cache.set(normalized, []);
-    return [];
-  }
-  const source = readFileSync(fullPath, "utf-8");
-  const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : isJavaScriptSourcePath(normalized) ? parseJavaScriptImports(db, normalized, source) : isJvmSourcePath(normalized) ? parseJvmImports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustImports(db, normalized, source) : isRubySourcePath(normalized) ? parseRubyImports(db, normalized, source) : isCLikeSourcePath(normalized) ? parseCLikeImports(db, normalized, source) : isDotNetSourcePath(normalized) ? parseDotNetImports(db, normalized, source) : isDartSourcePath(normalized) ? parseDartImports(db, normalized, source) : isPhpSourcePath(normalized) ? parsePhpImports(db, normalized, source) : [];
-  cache.set(normalized, parsed);
-  return parsed;
-}
-function getSourceExports(db, relativePath) {
-  const cache = getCachedMap(SOURCE_EXPORT_CACHE, db);
-  const normalized = normalizePath(relativePath);
-  const cached = cache.get(normalized);
-  if (cached) {
-    return cached;
-  }
-  const fullPath = join(db.config.projectRoot, normalized);
-  if (!existsSync(fullPath)) {
-    cache.set(normalized, []);
-    return [];
-  }
-  const source = readFileSync(fullPath, "utf-8");
-  const parsed = isDartSourcePath(normalized) ? parseDartExports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustExports(db, normalized, source) : [];
-  cache.set(normalized, parsed);
-  return parsed;
-}
-function getSourceCalls(db, relativePath, opts = {}) {
-  const normalized = normalizePath(relativePath);
-  if (!isPythonSourcePath(normalized) && !isJavaScriptSourcePath(normalized)) {
-    return [];
-  }
-  const cache = getCachedMap(SOURCE_CALL_CACHE, db);
-  const key = `${normalized}:${opts.startLine ?? 0}:${opts.endLine ?? Number.MAX_SAFE_INTEGER}`;
-  const cached = cache.get(key);
-  if (cached) {
-    return cached;
-  }
-  const source = getSourceText(db, normalized);
-  if (!source) {
-    cache.set(key, []);
-    return [];
-  }
-  const lines = source.split("\n");
-  const startLine = Math.max(0, opts.startLine ?? 0);
-  const endLine = Math.min(lines.length - 1, opts.endLine ?? lines.length - 1);
-  const scopedLines = lines.slice(startLine, endLine + 1);
-  const calls = isPythonSourcePath(normalized) ? parsePythonCalls(scopedLines, startLine) : parseJavaScriptCalls(scopedLines, startLine);
-  cache.set(key, calls);
-  return calls;
-}
-function getSourceConstructorBindings(db, relativePath, opts = {}) {
-  const normalized = normalizePath(relativePath);
-  if (!isPythonSourcePath(normalized) && !isJavaScriptSourcePath(normalized)) {
-    return [];
-  }
-  const cache = getCachedMap(SOURCE_BINDING_CACHE, db);
-  const key = `${normalized}:${opts.startLine ?? 0}:${opts.endLine ?? Number.MAX_SAFE_INTEGER}`;
-  const cached = cache.get(key);
-  if (cached) {
-    return cached;
-  }
-  const source = getSourceText(db, normalized);
-  if (!source) {
-    cache.set(key, []);
-    return [];
-  }
-  const lines = source.split("\n");
-  const startLine = Math.max(0, opts.startLine ?? 0);
-  const endLine = Math.min(lines.length - 1, opts.endLine ?? lines.length - 1);
-  const scopedLines = lines.slice(startLine, endLine + 1);
-  const bindings = isPythonSourcePath(normalized) ? parsePythonConstructorBindings(scopedLines) : parseJavaScriptConstructorBindings(scopedLines);
-  cache.set(key, bindings);
-  return bindings;
-}
-function findIdentifierLines(db, relativePath, identifier, opts = {}) {
-  if (!identifier) {
-    return [];
-  }
-  const source = getSourceText(db, normalizePath(relativePath));
-  if (!source) {
-    return [];
-  }
-  const lines = stripCommentsAndStrings(source).split("\n");
-  const regex = new RegExp(`\\b${escapeRegex(identifier)}\\b`);
-  const results = [];
-  for (let line = 0; line < lines.length; line++) {
-    if (typeof opts.excludeStartLine === "number" && typeof opts.excludeEndLine === "number" && line >= opts.excludeStartLine && line <= opts.excludeEndLine) {
-      continue;
-    }
-    if (regex.test(lines[line] ?? "")) {
-      results.push(line);
-    }
-  }
-  return results;
-}
-function parseJavaScriptImports(db, importerPath, source) {
-  return parseJavaScriptImportStatements(source).flatMap((statement) => parseJavaScriptImportStatement(
-    db,
-    importerPath,
-    statement.clause,
-    statement.specifier,
-    statement.start,
-    statement.end,
-    source
-  ));
-}
-function parseJavaScriptImportStatements(source) {
-  const statements = [];
-  const importFromRegex = /^[ \t]*import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]\s*;?/gm;
-  for (const match of source.matchAll(importFromRegex)) {
-    const full = match[0];
-    const clause = match[1];
-    const specifier = match[2];
-    if (!full || !specifier || typeof match.index !== "number") continue;
-    statements.push({
-      clause,
-      specifier,
-      start: match.index,
-      end: match.index + full.length
-    });
-  }
-  const sideEffectRegex = /^[ \t]*import\s+['"]([^'"]+)['"]\s*;?/gm;
-  for (const match of source.matchAll(sideEffectRegex)) {
-    const full = match[0];
-    const specifier = match[1];
-    if (!full || !specifier || typeof match.index !== "number") continue;
-    statements.push({
-      clause: null,
-      specifier,
-      start: match.index,
-      end: match.index + full.length
-    });
-  }
-  return statements.sort((a, b) => a.start - b.start);
-}
-function parseJavaScriptImportStatement(db, importerPath, clause, specifier, start, end, source) {
-  const resolvedSource = resolveImportPath(db, importerPath, specifier);
-  const body = buildUsageBody(source, start, end);
-  if (!clause) {
-    return [{
-      importedName: "*",
-      localName: null,
-      sourcePath: resolvedSource,
-      kind: "side-effect",
-      used: true,
-      usedMembers: []
-    }];
-  }
-  const bindings = parseImportClause(clause).map((binding) => ({
-    ...binding,
-    sourcePath: resolvedSource
-  }));
-  return bindings.map((binding) => {
-    if (binding.kind === "namespace") {
-      const usedMembers = collectNamespaceMembers(body, binding.localName);
-      return {
-        ...binding,
-        used: usedMembers.length > 0 || hasIdentifierUsage(body, binding.localName),
-        usedMembers
-      };
-    }
-    if (binding.kind === "side-effect") {
-      return { ...binding, used: true, usedMembers: [] };
-    }
-    return {
-      ...binding,
-      used: binding.localName ? hasIdentifierUsage(body, binding.localName) : false,
-      usedMembers: []
-    };
-  });
-}
-function parseJvmImports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*import\s+(?:static\s+)?(.+?)\s*;?$/gm)) {
-    const clause = match[1]?.trim();
-    const full = match[0];
-    if (!clause || !full || typeof match.index !== "number") continue;
-    const body = buildUsageBody(source, match.index, match.index + full.length);
-    statements.push(...parseJvmImportClause(db, importerPath, clause, body));
-  }
-  return statements;
-}
-function parseJvmImportClause(db, importerPath, clause, body) {
-  if (clause.includes("{") && clause.includes("}")) {
-    const prefix = clause.slice(0, clause.indexOf("{")).replace(/\.$/, "").trim();
-    const inner = clause.slice(clause.indexOf("{") + 1, clause.lastIndexOf("}")).trim();
-    return splitTopLevel(inner).flatMap((entry) => {
-      const cleaned = entry.trim();
-      if (!cleaned) return [];
-      const [importedPart, aliasPart] = cleaned.includes("=>") ? cleaned.split(/\s*=>\s*/) : cleaned.split(/\s+as\s+/);
-      const importedName = importedPart?.trim();
-      if (!importedName || importedName === "_") return [];
-      const localName = (aliasPart ?? importedName.split(".").pop() ?? importedName).trim();
-      const qualified = importedName === "_" ? prefix : `${prefix}.${importedName}`.replace(/\.\./g, ".");
-      return [buildSimpleImport(db, importerPath, body, qualified, importedName, localName)];
-    });
-  }
-  return [buildSimpleImport(
-    db,
-    importerPath,
-    body,
-    clause,
-    clause.split(".").pop() ?? clause,
-    clause.split(".").pop() ?? clause
-  )];
-}
-function parseRustImports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*use\s+(.+?)\s*;$/gm)) {
-    const clause = match[1]?.trim();
-    const full = match[0];
-    if (!clause || !full || typeof match.index !== "number") continue;
-    const body = buildUsageBody(source, match.index, match.index + full.length);
-    statements.push(...parseRustUseClause(db, importerPath, clause, body));
-  }
-  return statements;
-}
-function parseRustUseClause(db, importerPath, clause, body) {
-  const trimmed = clause.trim();
-  if (trimmed.includes("{") && trimmed.includes("}")) {
-    const prefix = trimmed.slice(0, trimmed.indexOf("{")).replace(/::$/, "").trim();
-    const inner = trimmed.slice(trimmed.indexOf("{") + 1, trimmed.lastIndexOf("}")).trim();
-    return splitTopLevel(inner).flatMap((entry) => {
-      const cleaned = entry.trim();
-      if (!cleaned || cleaned === "self") return [];
-      const [importedPart2, aliasPart2] = cleaned.split(/\s+as\s+/);
-      const importedName2 = importedPart2?.trim();
-      if (!importedName2) return [];
-      const localName2 = (aliasPart2 ?? importedName2.split("::").pop() ?? importedName2).trim();
-      const moduleSpecifier = `${prefix}::${importedName2}`.replace(/::::/g, "::");
-      return [buildSimpleImport(
-        db,
-        importerPath,
-        body,
-        moduleSpecifier,
-        importedName2.split("::").pop() ?? importedName2,
-        localName2,
-        resolveRustImportPath(db, importerPath, prefix)
-      )];
-    });
-  }
-  const [importedPart, aliasPart] = trimmed.split(/\s+as\s+/);
-  const importedName = importedPart?.trim() ?? trimmed;
-  const localName = (aliasPart ?? importedName.split("::").pop() ?? importedName).trim();
-  const resolved = resolveRustImportPath(db, importerPath, importedName) ?? resolveRustImportPath(db, importerPath, importedName.split("::").slice(0, -1).join("::"));
-  return [buildSimpleImport(
-    db,
-    importerPath,
-    body,
-    importedName,
-    importedName.split("::").pop() ?? importedName,
-    localName,
-    resolved
-  )];
-}
-function parseRustExports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*pub\s+use\s+(.+?)\s*;$/gm)) {
-    const clause = match[1]?.trim();
-    if (!clause) continue;
-    statements.push(...parseRustExportClause(db, importerPath, clause));
-  }
-  return statements;
-}
-function parseRustExportClause(db, importerPath, clause) {
-  const trimmed = clause.trim();
-  if (trimmed.includes("{") && trimmed.includes("}")) {
-    const prefix = trimmed.slice(0, trimmed.indexOf("{")).replace(/::$/, "").trim();
-    const inner = trimmed.slice(trimmed.indexOf("{") + 1, trimmed.lastIndexOf("}")).trim();
-    return splitTopLevel(inner).flatMap((entry) => {
-      const cleaned = entry.trim();
-      if (!cleaned || cleaned === "self") return [];
-      const [qualifiedPart] = cleaned.split(/\s+as\s+/);
-      const qualified = `${prefix}::${qualifiedPart?.trim() ?? cleaned}`.replace(/::::/g, "::");
-      return [buildRustExport(db, importerPath, qualified)];
-    });
-  }
-  return [buildRustExport(db, importerPath, trimmed)];
-}
-function buildRustExport(db, importerPath, specifier) {
-  return {
-    specifier,
-    sourcePath: resolveRustImportPath(db, importerPath, specifier) ?? resolveRustImportPath(db, importerPath, specifier.split("::").slice(0, -1).join("::"))
-  };
-}
-function parseRubyImports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*(require_relative|require)\s+["']([^"']+)["']\s*$/gm)) {
-    const kind = match[1];
-    const specifier = match[2];
-    const full = match[0];
-    if (!kind || !specifier || !full || typeof match.index !== "number") continue;
-    const body = buildUsageBody(source, match.index, match.index + full.length);
-    const sourcePath = kind === "require_relative" ? resolveRubyImportPath(db, importerPath, specifier) : null;
-    if (sourcePath) {
-      const localName = rubyConstantName(specifier);
-      statements.push({
-        importedName: localName,
-        localName,
-        sourcePath,
-        kind: "named",
-        used: hasIdentifierUsage(body, localName),
-        usedMembers: []
-      });
-      continue;
-    }
-    statements.push({
-      importedName: specifier,
-      localName: null,
-      sourcePath,
-      kind: "side-effect",
-      used: true,
-      usedMembers: []
-    });
-  }
-  return statements;
-}
-function rubyConstantName(specifier) {
-  return basename(specifier).replace(/\.[^.]+$/, "").split("_").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function parseCLikeImports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*#include\s+[<"]([^">]+)[">]\s*$/gm)) {
-    const specifier = match[1]?.trim();
-    const full = match[0];
-    if (!specifier || !full || typeof match.index !== "number") continue;
-    const body = buildUsageBody(source, match.index, match.index + full.length);
-    const localName = basename(specifier).replace(/\.[^.]+$/, "");
-    statements.push({
-      importedName: specifier,
-      localName,
-      sourcePath: resolveCLikeImportPath(db, importerPath, specifier),
-      kind: "named",
-      used: hasIdentifierUsage(body, localName),
-      usedMembers: []
-    });
-  }
-  return statements;
-}
-function parseDotNetImports(db, importerPath, source) {
-  const statements = [];
-  const lineRegex = isVisualBasicSourcePath(importerPath) ? /^[ \t]*Imports\s+(.+?)\s*$/gm : /^[ \t]*using\s+(.+?)\s*;$/gm;
-  for (const match of source.matchAll(lineRegex)) {
-    const clause = match[1]?.trim();
-    const full = match[0];
-    if (!clause || !full || typeof match.index !== "number") continue;
-    const body = buildUsageBody(source, match.index, match.index + full.length);
-    const [aliasPart, targetPart] = isVisualBasicSourcePath(importerPath) ? clause.split(/\s*=\s*/) : clause.split(/\s*=\s*/);
-    const hasAlias = Boolean(targetPart);
-    const qualified = (hasAlias ? targetPart : aliasPart)?.trim() ?? clause;
-    const importedName = qualified.split(".").pop() ?? qualified;
-    const localName = hasAlias ? aliasPart?.trim() ?? importedName : importedName;
-    statements.push(buildSimpleImport(
-      db,
-      importerPath,
-      body,
-      qualified,
-      importedName,
-      localName,
-      resolveQualifiedImportPath(db, qualified, DOTNET_SOURCE_EXTENSIONS)
-    ));
-  }
-  return statements;
-}
-function parseDartImports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*import\s+['"]([^'"]+)['"](?:\s+as\s+([A-Za-z_]\w*))?[\s\S]*?;$/gm)) {
-    const specifier = match[1]?.trim();
-    const alias = match[2]?.trim() ?? null;
-    const full = match[0];
-    if (!specifier || !full || typeof match.index !== "number") continue;
-    const body = buildUsageBody(source, match.index, match.index + full.length);
-    statements.push({
-      importedName: specifier,
-      localName: alias,
-      sourcePath: resolveDartImportPath(db, importerPath, specifier),
-      kind: alias ? "namespace" : "side-effect",
-      used: alias ? hasIdentifierUsage(body, alias) : true,
-      usedMembers: alias ? collectNamespaceMembers(body, alias) : []
-    });
-  }
-  return statements;
-}
-function parseDartExports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*export\s+['"]([^'"]+)['"][\s\S]*?;$/gm)) {
-    const specifier = match[1]?.trim();
-    if (!specifier) continue;
-    statements.push({
-      specifier,
-      sourcePath: resolveDartImportPath(db, importerPath, specifier)
-    });
-  }
-  return statements;
-}
-function parsePhpImports(db, importerPath, source) {
-  const statements = [];
-  for (const match of source.matchAll(/^[ \t]*use\s+(.+?)\s*;$/gm)) {
-    const clause = match[1]?.trim();
-    const full = match[0];
-    if (!clause || !full || typeof match.index !== "number") continue;
-    const body = buildUsageBody(source, match.index, match.index + full.length);
-    for (const entry of splitTopLevel(clause)) {
-      const cleaned = entry.trim();
-      if (!cleaned) continue;
-      const [qualifiedPart, aliasPart] = cleaned.split(/\s+as\s+/i);
-      const qualified = qualifiedPart?.trim() ?? cleaned;
-      const importedName = qualified.split("\\").pop() ?? qualified;
-      const localName = (aliasPart ?? importedName).trim();
-      statements.push(buildSimpleImport(
-        db,
-        importerPath,
-        body,
-        qualified,
-        importedName,
-        localName,
-        resolveQualifiedImportPath(db, qualified.replace(/\\/g, "."), PHP_SOURCE_EXTENSIONS)
-      ));
-    }
-  }
-  return statements;
-}
-function buildSimpleImport(db, importerPath, body, qualifiedName, importedName, localName, sourcePath) {
-  return {
-    importedName,
-    localName,
-    sourcePath: sourcePath ?? resolveQualifiedImportPath(db, qualifiedName, extensionFamilyFor(importerPath)),
-    kind: "named",
-    used: hasIdentifierUsage(body, localName),
-    usedMembers: []
-  };
-}
-function parsePythonCalls(lines, baseLine) {
-  const calls = [];
-  const controlKeywords = /* @__PURE__ */ new Set([
-    "if",
-    "for",
-    "while",
-    "with",
-    "except",
-    "elif",
-    "return",
-    "yield",
-    "assert",
-    "raise",
-    "lambda",
-    "class",
-    "def"
-  ]);
-  for (let index = 0; index < lines.length; index++) {
-    const rawLine = lines[index] ?? "";
-    const stripped = stripCommentsAndStrings(rawLine);
-    if (!stripped.trim()) continue;
-    const attributeMatches = [...stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\.\s*([A-Za-z_][\w]*)\s*\(/g)];
-    const attributeRanges = attributeMatches.map((match) => ({
-      start: match.index ?? -1,
-      end: (match.index ?? -1) + match[0].length
-    }));
-    for (const match of attributeMatches) {
-      const receiverName = match[1];
-      const calleeName = match[2];
-      if (!receiverName || !calleeName) continue;
-      calls.push({
-        receiverName,
-        calleeName,
-        line: baseLine + index
-      });
-    }
-    for (const match of stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\(/g)) {
-      const calleeName = match[1];
-      const start = match.index ?? -1;
-      if (!calleeName || start < 0) continue;
-      if (controlKeywords.has(calleeName)) continue;
-      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
-      const prefix = stripped.slice(0, start).trimEnd();
-      if (prefix.endsWith("def") || prefix.endsWith("class") || prefix.endsWith("async def")) {
-        continue;
-      }
-      calls.push({
-        receiverName: null,
-        calleeName,
-        line: baseLine + index
-      });
-    }
-  }
-  return calls;
-}
-function parseJavaScriptCalls(lines, baseLine) {
-  const calls = [];
-  const controlKeywords = /* @__PURE__ */ new Set([
-    "if",
-    "for",
-    "while",
-    "switch",
-    "catch",
-    "function",
-    "class",
-    "return",
-    "typeof",
-    "import"
-  ]);
-  for (let index = 0; index < lines.length; index++) {
-    const stripped = stripCommentsAndStrings(lines[index] ?? "");
-    if (!stripped.trim()) continue;
-    const attributeMatches = [
-      ...stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g),
-      ...stripped.matchAll(/\bthis\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g)
-    ];
-    const attributeRanges = attributeMatches.map((match) => ({
-      start: match.index ?? -1,
-      end: (match.index ?? -1) + match[0].length
-    }));
-    for (const match of attributeMatches) {
-      const receiverName = match[2] ? match[1] : "this";
-      const calleeName = match[2] ?? match[1];
-      if (!receiverName || !calleeName) continue;
-      calls.push({
-        receiverName,
-        calleeName,
-        line: baseLine + index
-      });
-    }
-    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
-      const calleeName = match[1];
-      const start = match.index ?? -1;
-      if (!calleeName || start < 0) continue;
-      if (controlKeywords.has(calleeName)) continue;
-      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
-      const prefix = stripped.slice(0, start).trimEnd();
-      if (prefix.endsWith("function") || prefix.endsWith("class") || prefix.endsWith("new")) {
-        continue;
-      }
-      calls.push({
-        receiverName: null,
-        calleeName,
-        line: baseLine + index
-      });
-    }
-  }
-  return calls;
-}
-function parsePythonConstructorBindings(lines) {
-  const bindings = /* @__PURE__ */ new Map();
-  for (const rawLine of lines) {
-    const stripped = stripCommentsAndStrings(rawLine);
-    const constructorMatch = stripped.match(/\b([A-Za-z_][\w]*)\s*=\s*([A-Z][\w]*)\s*\(/);
-    if (constructorMatch?.[1] && constructorMatch[2]) {
-      bindings.set(constructorMatch[1], constructorMatch[2]);
-    }
-  }
-  return [...bindings.entries()].map(([localName, typeName]) => ({ localName, typeName }));
-}
-function parseJavaScriptConstructorBindings(lines) {
-  const bindings = /* @__PURE__ */ new Map();
-  for (const rawLine of lines) {
-    const stripped = stripCommentsAndStrings(rawLine);
-    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*:\s*([A-Z][A-Za-z0-9_$]*)\b/g)) {
-      const localName = match[1];
-      const typeName = match[2];
-      if (localName && typeName) {
-        bindings.set(localName, typeName);
-      }
-    }
-    const constructorMatch = stripped.match(/\b(?:const|let|var)?\s*([A-Za-z_$][\w$]*)\s*(?::\s*[A-Z][A-Za-z0-9_$<> ,]*)?\s*=\s*new\s+([A-Z][A-Za-z0-9_$]*)\s*\(/);
-    if (constructorMatch?.[1] && constructorMatch[2]) {
-      bindings.set(constructorMatch[1], constructorMatch[2]);
-    }
-  }
-  return [...bindings.entries()].map(([localName, typeName]) => ({ localName, typeName }));
-}
-function parsePythonImports(db, importerPath, source) {
-  return collectPythonImportStatements(source).flatMap(
-    (statement) => parsePythonImportStatement(db, importerPath, statement, source)
-  );
-}
-function collectPythonImportStatements(source) {
-  const lines = source.split("\n");
-  const statements = [];
-  let offset = 0;
-  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-    const line = lines[lineIndex];
-    const trimmed = line.trimStart();
-    const lineStart = offset;
-    offset += line.length + 1;
-    if (!trimmed.startsWith("import ") && !trimmed.startsWith("from ")) {
-      continue;
-    }
-    let statement = line;
-    let statementEnd = lineStart + line.length;
-    let balance = pythonParenBalance(line);
-    while (lineIndex + 1 < lines.length && (balance > 0 || statement.trimEnd().endsWith("\\"))) {
-      lineIndex++;
-      const nextLine = lines[lineIndex];
-      statement += `
-${nextLine}`;
-      statementEnd += 1 + nextLine.length;
-      balance += pythonParenBalance(nextLine);
-      offset += nextLine.length + 1;
-    }
-    const parsed = parsePythonStatementHeader(statement);
-    if (parsed) {
-      statements.push({
-        ...parsed,
-        start: lineStart,
-        end: statementEnd
-      });
-    }
-  }
-  return statements;
-}
-function parsePythonStatementHeader(statement) {
-  const normalized = statement.replace(/\\\s*\n/g, " ").trim();
-  if (normalized.startsWith("import ")) {
-    return {
-      kind: "import",
-      module: null,
-      clause: normalized.slice("import ".length).trim()
-    };
-  }
-  const fromMatch = normalized.match(/^from\s+([.\w]+)\s+import\s+([\s\S]+)$/);
-  if (!fromMatch) {
-    return null;
-  }
-  let clause = fromMatch[2].trim();
-  if (clause.startsWith("(") && clause.endsWith(")")) {
-    clause = clause.slice(1, -1).trim();
-  }
-  return {
-    kind: "from",
-    module: fromMatch[1],
-    clause
-  };
-}
-function parsePythonImportStatement(db, importerPath, statement, source) {
-  const body = buildUsageBody(source, statement.start, statement.end);
-  const normalizedClause = statement.clause.replace(/\n/g, " ").trim();
-  if (statement.kind === "import") {
-    return splitTopLevel(normalizedClause).flatMap((entry) => {
-      const cleaned = entry.trim().replace(/,$/, "");
-      if (!cleaned) return [];
-      const [moduleName, alias] = cleaned.split(/\s+as\s+/);
-      const importedName = moduleName.trim();
-      const localName = (alias ?? importedName.split(".")[0] ?? importedName).trim();
-      const sourcePath2 = resolvePythonImportPath(db, importerPath, importedName);
-      const usedMembers = collectNamespaceMembers(body, localName);
-      return [{
-        importedName,
-        localName,
-        sourcePath: sourcePath2,
-        kind: "namespace",
-        used: hasIdentifierUsage(body, localName) || usedMembers.length > 0,
-        usedMembers
-      }];
-    });
-  }
-  const sourcePath = statement.module ? resolvePythonImportPath(db, importerPath, statement.module) : null;
-  const results = [];
-  for (const entry of splitTopLevel(normalizedClause)) {
-    const cleaned = entry.trim().replace(/,$/, "");
-    if (!cleaned) continue;
-    if (cleaned === "*") {
-      results.push({
-        importedName: "*",
-        localName: null,
-        sourcePath,
-        kind: "side-effect",
-        used: true,
-        usedMembers: []
-      });
-      continue;
-    }
-    const [importedName, alias] = cleaned.split(/\s+as\s+/);
-    const localName = (alias ?? importedName).trim();
-    results.push({
-      importedName: importedName.trim(),
-      localName,
-      sourcePath,
-      kind: "named",
-      used: hasIdentifierUsage(body, localName),
-      usedMembers: []
-    });
-  }
-  return results;
-}
-function parseImportClause(clause) {
-  const trimmed = clause.trim().replace(/^type\s+/, "");
-  const [first, second] = splitImportClause(trimmed);
-  const entries = [];
-  if (first) {
-    entries.push(...parseImportBinding(first));
-  }
-  if (second) {
-    entries.push(...parseImportBinding(second));
-  }
-  return entries;
-}
-function parseImportBinding(binding) {
-  const trimmed = binding.trim();
-  if (!trimmed) return [];
-  if (trimmed.startsWith("{")) {
-    const inner = trimmed.slice(1, -1).trim();
-    if (!inner) return [];
-    return splitTopLevel(inner).map((entry) => {
-      const cleaned = entry.trim().replace(/^type\s+/, "");
-      const [importedName, alias] = cleaned.split(/\s+as\s+/);
-      return {
-        importedName: importedName.trim(),
-        localName: (alias ?? importedName).trim(),
-        kind: "named"
-      };
-    });
-  }
-  if (trimmed.startsWith("* as ")) {
-    return [{
-      importedName: "*",
-      localName: trimmed.slice(5).trim(),
-      kind: "namespace"
-    }];
-  }
-  return [{
-    importedName: "default",
-    localName: trimmed,
-    kind: "default"
-  }];
-}
-function splitImportClause(clause) {
-  let depth = 0;
-  for (let i = 0; i < clause.length; i++) {
-    const char = clause[i];
-    if (char === "{") depth++;
-    if (char === "}") depth--;
-    if (char === "," && depth === 0) {
-      return [clause.slice(0, i).trim(), clause.slice(i + 1).trim()];
-    }
-  }
-  return [clause.trim(), null];
-}
-function splitTopLevel(input) {
-  const parts = [];
-  let depth = 0;
-  let start = 0;
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    if (char === "{" || char === "[" || char === "(") depth++;
-    if (char === "}" || char === "]" || char === ")") depth--;
-    if (char === "," && depth === 0) {
-      parts.push(input.slice(start, i));
-      start = i + 1;
-    }
-  }
-  parts.push(input.slice(start));
-  return parts;
-}
-function buildUsageBody(source, start, end) {
-  const masked = `${source.slice(0, start)}${" ".repeat(end - start)}${source.slice(end)}`;
-  return stripCommentsAndStrings(masked);
-}
-function stripCommentsAndStrings(source) {
-  return source.replace(/'''[\s\S]*?'''/g, maskPreservingLines).replace(/"""[\s\S]*?"""/g, maskPreservingLines).replace(/#.*$/gm, maskPreservingLines).replace(/\/\/.*$/gm, maskPreservingLines).replace(/\/\*[\s\S]*?\*\//g, maskPreservingLines).replace(/`(?:\\[\s\S]|[^`])*`/g, maskPreservingLines).replace(/'(?:\\.|[^'\\\r\n])*'/g, maskPreservingLines).replace(/"(?:\\.|[^"\\\r\n])*"/g, maskPreservingLines);
-}
-function maskPreservingLines(segment) {
-  return segment.replace(/[^\r\n]/g, " ");
-}
-function hasIdentifierUsage(body, identifier) {
-  return new RegExp(`\\b${escapeRegex(identifier)}\\b`, "m").test(body);
-}
-function collectNamespaceMembers(body, namespaceName) {
-  const members = /* @__PURE__ */ new Set();
-  const regex = new RegExp(`\\b${escapeRegex(namespaceName)}\\s*\\.\\s*([A-Za-z_$][\\w$]*)`, "g");
-  for (const match of body.matchAll(regex)) {
-    const member = match[1];
-    if (member) {
-      members.add(member);
-    }
-  }
-  return [...members];
-}
-function resolveImportPath(db, importerPath, specifier) {
-  if (isPythonSourcePath(importerPath)) {
-    return resolvePythonImportPath(db, importerPath, specifier);
-  }
-  if (isRustSourcePath(importerPath)) {
-    return resolveRustImportPath(db, importerPath, specifier);
-  }
-  if (isRubySourcePath(importerPath)) {
-    return resolveRubyImportPath(db, importerPath, specifier);
-  }
-  if (isCLikeSourcePath(importerPath)) {
-    return resolveCLikeImportPath(db, importerPath, specifier);
-  }
-  if (isJvmSourcePath(importerPath) || isDotNetSourcePath(importerPath) || isPhpSourcePath(importerPath)) {
-    return resolveQualifiedImportPath(db, specifier.replace(/\\/g, "."), extensionFamilyFor(importerPath));
-  }
-  if (isDartSourcePath(importerPath)) {
-    return resolveDartImportPath(db, importerPath, specifier);
-  }
-  return resolveJavaScriptImportPath(db, importerPath, specifier);
-}
-function resolveJavaScriptImportPath(db, importerPath, specifier) {
-  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
-    return null;
-  }
-  const importerDir = dirname(join(db.config.projectRoot, importerPath));
-  const absolute = resolve(importerDir, specifier);
-  const indexedPaths = getIndexedPaths(db);
-  for (const candidate of candidateImportPaths(absolute)) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return normalizePath(relative(db.config.projectRoot, absolute));
-}
-function resolvePythonImportPath(db, importerPath, specifier) {
-  const indexedPaths = getIndexedPaths(db);
-  let basePath;
-  if (specifier.startsWith(".")) {
-    const match = specifier.match(/^(\.+)(.*)$/);
-    if (!match) return null;
-    const dots = match[1].length;
-    const remainder = match[2].replace(/^\./, "");
-    let baseDir = dirname(join(db.config.projectRoot, importerPath));
-    for (let i = 1; i < dots; i++) {
-      baseDir = dirname(baseDir);
-    }
-    basePath = remainder ? resolve(baseDir, remainder.replace(/\./g, "/")) : baseDir;
-  } else {
-    basePath = resolve(db.config.projectRoot, specifier.replace(/\./g, "/"));
-  }
-  for (const candidate of pythonCandidateImportPaths(basePath)) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return null;
-}
-function resolveRustImportPath(db, importerPath, specifier) {
-  if (!specifier) return null;
-  const normalizedSpecifier = specifier.replace(/\s+as\s+.+$/, "").trim();
-  if (!normalizedSpecifier.startsWith("crate::") && !normalizedSpecifier.startsWith("self::") && !normalizedSpecifier.startsWith("super::")) {
-    return null;
-  }
-  const importerDir = dirname(join(db.config.projectRoot, importerPath));
-  let basePath;
-  if (normalizedSpecifier.startsWith("crate::")) {
-    basePath = resolve(db.config.projectRoot, "src", normalizedSpecifier.slice("crate::".length).replace(/::/g, "/"));
-  } else if (normalizedSpecifier.startsWith("self::")) {
-    basePath = resolve(importerDir, normalizedSpecifier.slice("self::".length).replace(/::/g, "/"));
-  } else {
-    basePath = resolve(dirname(importerDir), normalizedSpecifier.slice("super::".length).replace(/::/g, "/"));
-  }
-  for (const candidate of rustCandidateImportPaths(basePath)) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (getIndexedPaths(db).has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return null;
-}
-function resolveRubyImportPath(db, importerPath, specifier) {
-  const importerDir = dirname(join(db.config.projectRoot, importerPath));
-  const absolute = resolve(importerDir, specifier);
-  for (const candidate of rubyCandidateImportPaths(absolute)) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (getIndexedPaths(db).has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return null;
-}
-function resolveCLikeImportPath(db, importerPath, specifier) {
-  const indexedPaths = getIndexedPaths(db);
-  const importerDir = dirname(join(db.config.projectRoot, importerPath));
-  const candidates = [
-    resolve(importerDir, specifier),
-    resolve(db.config.projectRoot, specifier),
-    resolve(db.config.projectRoot, "include", specifier),
-    resolve(db.config.projectRoot, "src", specifier)
-  ];
-  for (const candidate of candidates) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return null;
-}
-function resolveQualifiedImportPath(db, specifier, extensions) {
-  const indexedPaths = getIndexedPaths(db);
-  const normalized = specifier.replace(/\\/g, ".").replace(/::/g, ".").replace(/^global::/, "");
-  const pathified = normalized.replace(/\./g, "/");
-  const basenameOnly = normalized.split(".").pop() ?? normalized;
-  for (const ext of extensions) {
-    const exactSuffix = `${pathified}${ext}`;
-    const exact = [...indexedPaths].find((relativePath) => relativePath.endsWith(exactSuffix));
-    if (exact) return exact;
-  }
-  for (const ext of extensions) {
-    const basenameMatch = [...indexedPaths].find((relativePath) => basename(relativePath) === `${basenameOnly}${ext}`);
-    if (basenameMatch) return basenameMatch;
-  }
-  const folderMatches = [...indexedPaths].filter((relativePath) => extensions.includes(extname(relativePath).toLowerCase())).filter((relativePath) => relativePath.includes(`/${pathified}/`) || relativePath.includes(`/${basenameOnly}/`)).sort((left, right) => left.localeCompare(right));
-  if (folderMatches.length === 1) {
-    return folderMatches[0];
-  }
-  return null;
-}
-function resolveDartImportPath(db, importerPath, specifier) {
-  const indexedPaths = getIndexedPaths(db);
-  if (specifier.startsWith("package:")) {
-    const withoutScheme = specifier.slice("package:".length);
-    const slashIndex = withoutScheme.indexOf("/");
-    if (slashIndex < 0) return null;
-    const packageRelative = withoutScheme.slice(slashIndex + 1);
-    const candidate = normalizePath(packageRelative.startsWith("lib/") ? packageRelative : `lib/${packageRelative}`);
-    if (indexedPaths.has(candidate)) return candidate;
-    return null;
-  }
-  const importerDir = dirname(join(db.config.projectRoot, importerPath));
-  const absolute = resolve(importerDir, specifier);
-  for (const candidate of dartCandidateImportPaths(absolute)) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return null;
-}
-function pythonCandidateImportPaths(basePath) {
-  const ext = extname(basePath);
-  if (PYTHON_SOURCE_EXTENSIONS.includes(ext)) {
-    return [basePath];
-  }
-  return [
-    `${basePath}.py`,
-    `${basePath}.pyi`,
-    join(basePath, "__init__.py"),
-    join(basePath, "__init__.pyi")
-  ];
-}
-function rustCandidateImportPaths(basePath) {
-  const ext = extname(basePath);
-  if (RUST_SOURCE_EXTENSIONS.includes(ext)) {
-    return [basePath];
-  }
-  return [
-    `${basePath}.rs`,
-    join(basePath, "mod.rs")
-  ];
-}
-function rubyCandidateImportPaths(basePath) {
-  const ext = extname(basePath);
-  if (RUBY_SOURCE_EXTENSIONS.includes(ext)) {
-    return [basePath];
-  }
-  return [
-    `${basePath}.rb`,
-    join(basePath, "index.rb")
-  ];
-}
-function dartCandidateImportPaths(basePath) {
-  const ext = extname(basePath);
-  if (DART_SOURCE_EXTENSIONS.includes(ext)) {
-    return [basePath];
-  }
-  return [`${basePath}.dart`, basePath];
-}
-function candidateImportPaths(absolute) {
-  const ext = extname(absolute);
-  const candidates = /* @__PURE__ */ new Set();
-  if (ext) {
-    candidates.add(absolute);
-    for (const sourceExt of SOURCE_EXTENSIONS) {
-      candidates.add(absolute.slice(0, -ext.length) + sourceExt);
-    }
-  } else {
-    for (const sourceExt of SOURCE_EXTENSIONS) {
-      candidates.add(`${absolute}${sourceExt}`);
-      candidates.add(join(absolute, `index${sourceExt}`));
-    }
-  }
-  return [...candidates];
-}
-function getIndexedPaths(db) {
-  const cached = INDEXED_PATH_CACHE.get(db);
-  if (cached) {
-    return cached;
-  }
-  const paths = new Set(
-    db.all(
-      `SELECT relative_path
-       FROM documents
-       WHERE 1 = 1
-         ${db.pathExclusionsFor("documents")}`
-    ).map((row) => normalizePath(row.relative_path)).filter((relativePath) => !db.isIgnored(relativePath))
-  );
-  INDEXED_PATH_CACHE.set(db, paths);
-  return paths;
-}
-function getCachedMap(cache, db) {
-  let map = cache.get(db);
-  if (!map) {
-    map = /* @__PURE__ */ new Map();
-    cache.set(db, map);
-  }
-  return map;
-}
-function normalizePath(path) {
-  return path.replace(/\\/g, "/");
-}
-var LANGUAGE_EXTENSION_FAMILIES = [
-  SOURCE_EXTENSIONS,
-  PYTHON_SOURCE_EXTENSIONS,
-  JVM_SOURCE_EXTENSIONS,
-  RUST_SOURCE_EXTENSIONS,
-  RUBY_SOURCE_EXTENSIONS,
-  C_LIKE_SOURCE_EXTENSIONS,
-  DOTNET_SOURCE_EXTENSIONS,
-  DART_SOURCE_EXTENSIONS,
-  PHP_SOURCE_EXTENSIONS
-];
-function hasExtensionIn(relativePath, extensions) {
-  return extensions.includes(extname(relativePath).toLowerCase());
-}
-function isJavaScriptSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, SOURCE_EXTENSIONS);
-}
-function isPythonSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, PYTHON_SOURCE_EXTENSIONS);
-}
-function isJvmSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, JVM_SOURCE_EXTENSIONS);
-}
-function isRustSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, RUST_SOURCE_EXTENSIONS);
-}
-function isRubySourcePath(relativePath) {
-  return hasExtensionIn(relativePath, RUBY_SOURCE_EXTENSIONS);
-}
-function isCLikeSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, C_LIKE_SOURCE_EXTENSIONS);
-}
-function isDotNetSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, DOTNET_SOURCE_EXTENSIONS);
-}
-function isVisualBasicSourcePath(relativePath) {
-  return extname(relativePath).toLowerCase() === ".vb";
-}
-function isDartSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, DART_SOURCE_EXTENSIONS);
-}
-function isPhpSourcePath(relativePath) {
-  return hasExtensionIn(relativePath, PHP_SOURCE_EXTENSIONS);
-}
-function extensionFamilyFor(relativePath) {
-  const ext = extname(relativePath).toLowerCase();
-  for (const family of LANGUAGE_EXTENSION_FAMILIES) {
-    if (family.includes(ext)) return family;
-  }
-  return SOURCE_EXTENSIONS;
-}
-function getSourceText(db, relativePath) {
-  const cache = getCachedMap(SOURCE_TEXT_CACHE, db);
-  const normalized = normalizePath(relativePath);
-  const cached = cache.get(normalized);
-  if (typeof cached === "string") {
-    return cached;
-  }
-  const fullPath = join(db.config.projectRoot, normalized);
-  if (!existsSync(fullPath)) {
-    cache.set(normalized, "");
-    return "";
-  }
-  const source = readFileSync(fullPath, "utf-8");
-  cache.set(normalized, source);
-  return source;
-}
-function pythonParenBalance(value) {
-  let balance = 0;
-  for (const char of value) {
-    if (char === "(") balance++;
-    if (char === ")") balance--;
-  }
-  return balance;
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/query-support.ts
-import { basename as basename2 } from "path";
-var FILE_DEFINITION_CACHE = /* @__PURE__ */ new WeakMap();
-var TEST_FILE_PATTERNS = [
-  "%/__tests__/%",
-  "%.test.%",
-  "%.spec.%",
-  "%/test/%",
-  "%/tests/%",
-  "%_test.%",
-  "%_spec.%",
-  "%/test_%.%",
-  "%/spec_%.%"
-];
-var TEST_SUPPORT_PATH_PATTERNS = [
-  "%/test-utils/%"
-];
-function buildFileDepGraph(db, scope) {
-  const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%'` : "";
-  const edges = db.all(
-    `SELECT DISTINCT
-      d1.relative_path AS from_file,
-      d2.relative_path AS to_file
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d1 ON c.document_id = d1.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d2 ON der.document_id = d2.id
-    WHERE d1.id != d2.id
-      AND m.role != 1
-      ${db.pathExclusionsFor("d1", "d2")}
-      ${scopeFilter}`
-  );
-  const graph = /* @__PURE__ */ new Map();
-  const indexedFiles = new Set(
-    db.all(
-      `SELECT relative_path
-       FROM documents
-       WHERE 1 = 1
-         ${db.pathExclusionsFor("documents")}
-       ORDER BY relative_path`
-    ).map((row) => row.relative_path).filter((relativePath) => !db.isIgnored(relativePath))
-  );
-  const addEdge = (fromFile, toFile) => {
-    if (fromFile === toFile) return;
-    if (db.isIgnored(fromFile) || db.isIgnored(toFile)) return;
-    if (!indexedFiles.has(toFile)) return;
-    if (!graph.has(fromFile)) graph.set(fromFile, /* @__PURE__ */ new Set());
-    graph.get(fromFile).add(toFile);
-  };
-  for (const edge of edges) {
-    addEdge(edge.from_file, edge.to_file);
-  }
-  for (const relativePath of indexedFiles) {
-    if (scope && !relativePath.includes(scope)) continue;
-    for (const entry of getSourceImports(db, relativePath)) {
-      if (!entry.sourcePath) continue;
-      addEdge(relativePath, entry.sourcePath);
-    }
-  }
-  return graph;
-}
-function findFirstSymbolMatch(db, symbolPattern) {
-  const exact = findExactSymbolMatch(db, symbolPattern.trim());
-  if (exact) {
-    return exact;
-  }
-  const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
-  if (fileLineMatch) {
-    const [, filePath, startStr, endStr] = fileLineMatch;
-    const userStart0 = Math.max(0, parseInt(startStr, 10) - 1);
-    const userEnd0 = Math.max(userStart0, parseInt(endStr, 10) - 1);
-    let row = db.get(
-      `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
-      FROM global_symbols gs
-      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-      JOIN documents d ON der.document_id = d.id
-      WHERE d.relative_path LIKE ?
-        AND der.start_line <= ? AND der.end_line >= ?
-        ${db.pathExclusionsFor("d")}
-      ORDER BY (der.end_line - der.start_line) ASC
-        LIMIT 1`,
-      `%${filePath}%`,
-      userStart0,
-      userEnd0
-    );
-    if (!row) {
-      row = db.get(
-        `SELECT gs.id, gs.symbol, c.document_id, MIN(c.start_line) AS start_line, MAX(c.end_line) AS end_line, d.relative_path
-         FROM global_symbols gs
-         JOIN mentions m ON m.symbol_id = gs.id
-         JOIN chunks c ON m.chunk_id = c.id
-         JOIN documents d ON c.document_id = d.id
-         WHERE m.role = 1
-           AND d.relative_path LIKE ?
-           AND c.start_line <= ? AND c.end_line >= ?
-           ${db.pathExclusionsFor("d")}
-         GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path
-         ORDER BY (MAX(c.end_line) - MIN(c.start_line)) ASC
-         LIMIT 1`,
-        `%${filePath}%`,
-        userStart0,
-        userEnd0
-      );
-    }
-    if (row && !db.isIgnored(row.relative_path)) {
-      return hydrateSymbolMatch(db, row);
-    }
-  }
-  const cleaned = normalizeLookupPattern(symbolPattern);
-  const tokens = lookupTokens(symbolPattern);
-  const candidates = getSymbolLookupCandidates(db, tokens);
-  const direct = findDirectSymbolCandidate(candidates, symbolPattern, cleaned);
-  if (direct && !db.isIgnored(direct.relative_path)) {
-    return hydrateSymbolMatch(db, direct);
-  }
-  let best = null;
-  for (const row of candidates) {
-    if (db.isIgnored(row.relative_path)) continue;
-    const score = scoreSymbolCandidate(row, symbolPattern, cleaned, tokens);
-    if (score <= 0) continue;
-    if (!best || score > best.score) {
-      best = { row, score };
-    }
-  }
-  if (best) {
-    return hydrateSymbolMatch(db, best.row);
-  }
-  return null;
-}
-function findExactSymbolMatch(db, symbol) {
-  const row = db.get(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
-     FROM global_symbols gs
-     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-     JOIN documents d ON der.document_id = d.id
-     WHERE gs.symbol = ?
-       ${db.pathExclusionsFor("d")}
-     ORDER BY d.relative_path, der.start_line
-     LIMIT 1`,
-    symbol
-  );
-  if (!row || db.isIgnored(row.relative_path)) {
-    return null;
-  }
-  return hydrateSymbolMatch(db, row);
-}
-function resolveIndexedFile(db, filePattern) {
-  return resolveDocumentCandidates(db, filePattern, { allowMultiple: false })[0]?.relativePath ?? null;
-}
-function resolveIndexedPaths(db, filePattern) {
-  return resolveDocumentCandidates(db, filePattern, { allowMultiple: true }).map((candidate) => candidate.relativePath);
-}
-function normalizeLookupPattern(symbolPattern) {
-  return symbolPattern.trim().replace(/\(\)$/, "").replace(/\(.*$/, "");
-}
-function lookupTokens(symbolPattern) {
-  const cleaned = normalizeLookupPattern(symbolPattern);
-  const tokens = cleaned.split(/[^A-Za-z0-9_]+/).map((token) => token.trim()).filter((token) => token.length > 0);
-  return tokens.length > 0 ? [...new Set(tokens)] : [cleaned];
-}
-function getSymbolLookupCandidates(db, tokens) {
-  const tokenClauses = tokens.map(
-    () => `(gs.symbol LIKE ? OR d.relative_path LIKE ? OR COALESCE(gs.display_name, '') LIKE ?)`
-  );
-  const params = tokens.flatMap((token) => {
-    const like = `%${token}%`;
-    return [like, like, like];
-  });
-  const primary = db.all(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path, gs.display_name
-     FROM global_symbols gs
-     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-     JOIN documents d ON der.document_id = d.id
-     WHERE ${tokenClauses.join("\n       AND ")}
-       ${db.pathExclusionsFor("d")}
-      LIMIT 200`,
-    ...params
-  );
-  if (primary.length > 0) {
-    return primary;
-  }
-  return db.all(
-    `SELECT
-      gs.id,
-      gs.symbol,
-      c.document_id,
-      MIN(c.start_line) AS start_line,
-      MAX(c.end_line) AS end_line,
-      d.relative_path,
-      gs.display_name
-     FROM global_symbols gs
-     JOIN mentions m ON m.symbol_id = gs.id
-     JOIN chunks c ON m.chunk_id = c.id
-     JOIN documents d ON c.document_id = d.id
-     WHERE m.role = 1
-       AND ${tokenClauses.join("\n       AND ")}
-       ${db.pathExclusionsFor("d")}
-     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path, gs.display_name
-     LIMIT 200`,
-    ...params
-  );
-}
-function scoreSymbolCandidate(row, originalPattern, cleanedPattern, tokens) {
-  const originalCase = originalPattern.trim();
-  const cleanedCase = cleanedPattern;
-  const noParensCase = cleanedCase.replace(/\(\)$/, "");
-  const original = originalPattern.toLowerCase();
-  const cleaned = cleanedPattern.toLowerCase();
-  const noParens = cleaned.replace(/\(\)$/, "");
-  const rawCase = row.symbol;
-  const shortCase = shortenSymbol(row.symbol);
-  const leafCase = leafName(row.symbol);
-  const displayCase = row.display_name ?? "";
-  const raw = row.symbol.toLowerCase();
-  const short = shortCase.toLowerCase();
-  const leaf = leafCase.toLowerCase();
-  const display = displayCase.toLowerCase();
-  const path = row.relative_path.toLowerCase();
-  const looksPathLike = /[/:.]/.test(cleanedPattern);
-  let score = 0;
-  if (rawCase === originalCase || rawCase === cleanedCase) score += 1150;
-  if (shortCase === originalCase || shortCase === cleanedCase) score += 1100;
-  if (displayCase === noParensCase) score += 980;
-  if (leafCase === noParensCase) score += 960;
-  if (`${leafCase}()` === originalCase || `${leafCase}()` === cleanedCase) score += 955;
-  if (raw === original || raw === cleaned) score += 1e3;
-  if (short === original || short === cleaned) score += 950;
-  if (path === original || path === cleaned) score += 925;
-  if (path.endsWith(`/${cleaned}`) || path.endsWith(`/${original}`)) score += 875;
-  if (display === noParens) score += 850;
-  if (leaf === noParens) score += 825;
-  if (`${leaf}()` === original || `${leaf}()` === cleaned) score += 820;
-  if (short.endsWith(`:${cleaned}`) || short.endsWith(`:${noParens}`) || short.endsWith(`:${noParens}()`)) score += 800;
-  if (raw.includes(cleaned)) score += 120;
-  if (short.includes(cleaned)) score += 140;
-  if (path.includes(cleaned)) score += 140;
-  if (display.includes(cleaned)) score += 110;
-  if (tokens.every((token) => {
-    const lower = token.toLowerCase();
-    return raw.includes(lower) || short.includes(lower) || path.includes(lower) || display.includes(lower);
-  })) {
-    score += 100 + tokens.length * 15;
-  }
-  if (isFunctionLikeSymbol(row.symbol) && leaf === noParens) {
-    score += 60;
-  }
-  if (!looksPathLike && isModuleLikeSymbol(row.symbol)) {
-    score -= 160;
-  }
-  score -= Math.min(50, Math.max(0, row.end_line - row.start_line));
-  return score;
-}
-function getCalleeRowsForSymbol(db, symbol, opts = {}) {
-  const mentions = db.all(
-    `SELECT DISTINCT m.symbol_id, c.id AS chunk_id
-     FROM mentions m
-     JOIN chunks c ON m.chunk_id = c.id
-     WHERE c.document_id = ?
-       AND c.start_line >= ?
-       AND c.end_line <= ?
-       AND m.role != 1
-       AND m.symbol_id != ?
-     ${opts.limit ? "LIMIT ?" : ""}`,
-    ...calleeQueryParams(symbol, opts.limit)
-  );
-  const primary = [];
-  const directSeen = /* @__PURE__ */ new Set();
-  for (const mention of mentions) {
-    const callee = getFullSymbolMatch(db, {
-      symbolId: mention.symbol_id,
-      documentId: symbol.documentId,
-      startLine: symbol.startLine,
-      endLine: symbol.endLine
-    });
-    if (!callee || db.isIgnored(callee.relativePath)) continue;
-    const key = `${callee.symbol}|${callee.relativePath}|${mention.chunk_id}`;
-    if (directSeen.has(key)) continue;
-    directSeen.add(key);
-    primary.push({
-      symbol: callee.symbol,
-      file: callee.relativePath,
-      chunkId: mention.chunk_id
-    });
-  }
-  const sourceFallback = getSourceBackedCalleeRows(db, symbol, opts.limit);
-  if (sourceFallback.length > 0) {
-    return applyLimit(sourceFallback, opts.limit);
-  }
-  return primary;
-}
-function getCallerRowsForSymbol(db, symbol, opts = {}) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match) {
-    return [];
-  }
-  const primary = db.all(
-    `SELECT DISTINCT ref_d.relative_path AS caller_file, c.start_line AS line
-     FROM mentions m
-     JOIN chunks c ON m.chunk_id = c.id
-     JOIN documents ref_d ON c.document_id = ref_d.id
-     WHERE m.symbol_id = ?
-       AND m.role != 1
-       ${db.pathExclusionsFor("ref_d")}
-     ORDER BY ref_d.relative_path
-     ${opts.limit ? "LIMIT ?" : ""}`,
-    ...referenceQueryParams(match, opts.limit)
-  ).filter((row) => !db.isIgnored(row.caller_file)).flatMap((row) => {
-    const enclosing = findEnclosingDefinition(getDefinitionsForFile(db, row.caller_file), row.line);
-    if (!enclosing || enclosing.symbolId === match.symbolId) {
-      return [];
-    }
-    return [{
-      symbol: enclosing.symbol,
-      file: row.caller_file
-    }];
-  });
-  const sourceFallback = dedupeCallerRows([
-    ...getPythonSourceCallerRows(db, match, opts.limit),
-    ...getGenericSourceCallerRows(db, match, opts.limit)
-  ]);
-  if (sourceFallback.length === 0) {
-    return dedupeCallerRows(primary);
-  }
-  const merged = [...sourceFallback];
-  const fallbackFiles = new Set(sourceFallback.map((row) => row.file));
-  const seen = new Set(merged.map((row) => `${row.symbol}|${row.file}`));
-  for (const row of primary) {
-    if (fallbackFiles.has(row.file)) continue;
-    const key = `${row.symbol}|${row.file}`;
-    if (seen.has(key)) continue;
-    if (isFunctionLikeSymbol(row.symbol) || merged.length === 0) {
-      seen.add(key);
-      merged.push(row);
-    }
-  }
-  return applyLimit(merged, opts.limit);
-}
-function getGenericSourceCallerRows(db, symbol, limit) {
-  return applyLimit(
-    getSourceReferenceSites(db, symbol).filter((site) => site.enclosingSymbol && site.enclosingSymbol !== symbol.symbol).map((site) => ({
-      symbol: site.enclosingSymbol,
-      file: site.file
-    })),
-    limit
-  );
-}
-function dedupeCallerRows(rows) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const row of rows) {
-    const key = `${row.symbol}|${row.file}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push(row);
-  }
-  return unique;
-}
-function getSourceReferenceSites(db, symbol) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match) {
-    return [];
-  }
-  const identifier = leafName(match.symbol);
-  if (!identifier || !hasUniqueLeafDefinition(db, identifier, match.symbolId)) {
-    return [];
-  }
-  const documents = db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-     ORDER BY relative_path`
-  );
-  const sites = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const document of documents) {
-    if (db.isIgnored(document.relative_path)) continue;
-    const lines = findIdentifierLines(db, document.relative_path, identifier, document.relative_path === match.relativePath ? { excludeStartLine: match.startLine, excludeEndLine: match.endLine } : {});
-    const definitions = getDefinitionsForFile(db, document.relative_path);
-    for (const line of lines) {
-      const enclosing = findEnclosingDefinition(definitions, line);
-      const key = `${document.relative_path}|${line}|${enclosing?.symbol ?? ""}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      sites.push({
-        file: document.relative_path,
-        line,
-        enclosingSymbol: enclosing?.symbol ?? null
-      });
-    }
-  }
-  return sites;
-}
-function getResolvedReferenceSites(db, symbol) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match) {
-    return [];
-  }
-  const rows = db.all(
-    `SELECT DISTINCT d.relative_path, c.start_line, c.end_line
-     FROM mentions m
-     JOIN chunks c ON m.chunk_id = c.id
-     JOIN documents d ON c.document_id = d.id
-     WHERE m.symbol_id = ?
-       AND m.role != 1
-       ${db.pathExclusionsFor("d")}
-     ORDER BY d.relative_path, c.start_line`,
-    match.symbolId
-  );
-  const chunksByFile = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (db.isIgnored(row.relative_path)) continue;
-    let bucket = chunksByFile.get(row.relative_path);
-    if (!bucket) {
-      bucket = [];
-      chunksByFile.set(row.relative_path, bucket);
-    }
-    bucket.push({ start_line: row.start_line, end_line: row.end_line });
-  }
-  const identifier = leafName(match.symbol);
-  const sites = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const [file, chunks] of chunksByFile) {
-    const definitions = getDefinitionsForFile(db, file);
-    const excludeOpts = file === match.relativePath ? { excludeStartLine: match.startLine, excludeEndLine: match.endLine } : {};
-    const allHits = identifier ? findIdentifierLines(db, file, identifier, excludeOpts) : [];
-    for (const chunk of chunks) {
-      const hitsInChunk = allHits.filter(
-        (line) => line >= chunk.start_line && line <= chunk.end_line
-      );
-      const lines = hitsInChunk.length > 0 ? hitsInChunk : [chunk.start_line];
-      for (const line of lines) {
-        const enclosing = findEnclosingDefinition(definitions, line);
-        const key = `${file}|${line}|${enclosing?.symbol ?? ""}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        sites.push({
-          file,
-          line,
-          enclosingSymbol: enclosing?.symbol ?? null
-        });
-      }
-    }
-  }
-  return sites;
-}
-function calleeQueryParams(symbol, limit) {
-  const params = [
-    symbol.documentId,
-    symbol.startLine,
-    symbol.endLine,
-    symbol.symbolId
-  ];
-  if (typeof limit === "number") {
-    params.push(limit);
-  }
-  return params;
-}
-function referenceQueryParams(symbol, limit) {
-  const params = [symbol.symbolId];
-  if (typeof limit === "number") {
-    params.push(limit);
-  }
-  return params;
-}
-function findEnclosingDefinition(definitions, line) {
-  let best = null;
-  for (const definition of definitions) {
-    if (definition.startLine > line || definition.endLine < line) continue;
-    if (!best || definition.endLine - definition.startLine < best.endLine - best.startLine) {
-      best = definition;
-    }
-  }
-  return best;
-}
-var LANGUAGE_CALLEE_CONFIGS = [
-  // Python (index 0) — complex resolver
-  { kind: "complex", languageIndex: 0, resolver: resolvePythonCallTarget },
-  // JavaScript/TypeScript (index 1) — complex resolver
-  { kind: "complex", languageIndex: 1, resolver: resolveJavaScriptCallTarget },
-  // Java (index 2) — simple with field bindings
-  { kind: "simple", languageIndex: 2, parseBindings: (_db, source) => parseJavaFieldBindings(source) },
-  // Kotlin (index 3) — simple with field bindings
-  { kind: "simple", languageIndex: 3, parseBindings: (_db, source) => parseKotlinFieldBindings(source) },
-  // Scala (index 4) — simple, no bindings
-  { kind: "simple", languageIndex: 4, parseBindings: null },
-  // C# (index 5) — simple, no bindings
-  { kind: "simple", languageIndex: 5, parseBindings: null },
-  // Visual Basic (index 6) — simple, no bindings
-  { kind: "simple", languageIndex: 6, parseBindings: null },
-  // C++ (index 7) — simple with receiver bindings
-  { kind: "simple", languageIndex: 7, parseBindings: (_db, source) => parseCppReceiverBindings(source) },
-  // Rust (index 8) — simple, no bindings
-  { kind: "simple", languageIndex: 8, parseBindings: null },
-  // Ruby (index 9) — simple with dual-attempt logic
-  {
-    kind: "simple",
-    languageIndex: 9,
-    parseBindings: (db, source) => parseRubyReceiverBindings(db, source),
-    dualAttempt: {
-      baseOpts: { allowInstanceVariables: true },
-      extendedOpts: { allowInstanceVariables: true, allowBareMemberCalls: true }
-    }
-  },
-  // Dart (index 10) — simple, no bindings
-  { kind: "simple", languageIndex: 10, parseBindings: null },
-  // PHP (index 11) — simple, no bindings
-  { kind: "simple", languageIndex: 11, parseBindings: null }
-];
-function getComplexSourceCalleeRows(db, match, config, limit) {
-  const definitions = getDefinitionsForFile(db, match.relativePath);
-  const current = definitions.find((definition) => definition.symbolId === match.symbolId);
-  if (!current) {
-    return [];
-  }
-  const imports = getSourceImports(db, match.relativePath);
-  const bindings = new Map(
-    getSourceConstructorBindings(db, match.relativePath, {
-      startLine: match.startLine,
-      endLine: match.endLine
-    }).map((binding) => [binding.localName, binding.typeName])
-  );
-  const rows = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const call of getSourceCalls(db, match.relativePath, {
-    startLine: match.startLine,
-    endLine: match.endLine
-  })) {
-    const resolved = config.resolver(
-      db,
-      current,
-      definitions,
-      imports,
-      bindings,
-      call.receiverName,
-      call.calleeName
-    );
-    if (!resolved || resolved.symbolId === match.symbolId || db.isIgnored(resolved.relativePath)) continue;
-    const chunkId = 1e9 + call.line;
-    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    rows.push({
-      symbol: resolved.symbol,
-      file: resolved.relativePath,
-      chunkId
-    });
-  }
-  return applyLimit(rows, limit);
-}
-function getSimpleLanguageCalleeRows(db, match, config, limit) {
-  let calls;
-  if (config.dualAttempt) {
-    const baseCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.dualAttempt.baseOpts);
-    const extendedCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.dualAttempt.extendedOpts);
-    calls = extendedCalls.length > 0 ? extendedCalls : baseCalls;
-  } else {
-    calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.sourceCallOpts);
-  }
-  const bindings = config.parseBindings ? config.parseBindings(db, getSourceText(db, match.relativePath)) : /* @__PURE__ */ new Map();
-  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
-}
-function getSourceBackedCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match) {
-    return [];
-  }
-  for (const config of LANGUAGE_CALLEE_CONFIGS) {
-    if (!isDocumentLanguage(db, match.relativePath, DOCUMENT_LANGUAGE_TABLE[config.languageIndex])) {
-      continue;
-    }
-    if (config.kind === "complex") {
-      return getComplexSourceCalleeRows(db, match, config, limit);
-    }
-    return getSimpleLanguageCalleeRows(db, match, config, limit);
-  }
-  return [];
-}
-function getPythonSourceCallerRows(db, target, limit) {
-  if (!isPythonDocument(db, target.relativePath)) {
-    return [];
-  }
-  const rows = [];
-  const seen = /* @__PURE__ */ new Set();
-  const pythonConfig = LANGUAGE_CALLEE_CONFIGS[0];
-  for (const candidate of getAllFunctionLikeDefinitions(db)) {
-    if (candidate.symbolId === target.symbolId) continue;
-    if (!isDocumentLanguage(db, candidate.relativePath, DOCUMENT_LANGUAGE_TABLE[pythonConfig.languageIndex])) continue;
-    const callees = getComplexSourceCalleeRows(db, candidate, pythonConfig);
-    if (!callees.some((callee) => callee.symbol === target.symbol)) continue;
-    const key = `${candidate.symbol}|${candidate.relativePath}`;
-    if (seen.has(key) || db.isIgnored(candidate.relativePath)) continue;
-    seen.add(key);
-    rows.push({
-      symbol: candidate.symbol,
-      file: candidate.relativePath
-    });
-    if (typeof limit === "number" && rows.length >= limit) {
-      break;
-    }
-  }
-  return rows;
-}
-function getDefinitionRowsForSymbolId(db, symbolId) {
-  const primary = db.all(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path, gs.display_name
-     FROM global_symbols gs
-     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-     JOIN documents d ON der.document_id = d.id
-     WHERE gs.id = ?
-     ORDER BY der.start_line, der.end_line`,
-    symbolId
-  );
-  if (primary.length > 0) {
-    return primary;
-  }
-  return db.all(
-    `SELECT
-      gs.id,
-      gs.symbol,
-      c.document_id,
-      MIN(c.start_line) AS start_line,
-      MAX(c.end_line) AS end_line,
-      d.relative_path,
-      gs.display_name
-     FROM global_symbols gs
-     JOIN mentions m ON m.symbol_id = gs.id
-     JOIN chunks c ON m.chunk_id = c.id
-     JOIN documents d ON c.document_id = d.id
-     WHERE gs.id = ?
-       AND m.role = 1
-       ${db.pathExclusionsFor("d")}
-     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path, gs.display_name
-     ORDER BY start_line, end_line`,
-    symbolId
-  );
-}
-function getFullSymbolMatch(db, symbol) {
-  if ("symbol" in symbol && "relativePath" in symbol) {
-    return symbol;
-  }
-  const row = getDefinitionRowsForSymbolId(db, symbol.symbolId)[0];
-  if (!row) {
-    return null;
-  }
-  return hydrateSymbolMatch(db, row);
-}
-function getDefinitionsForFile(db, relativePath) {
-  let cache = FILE_DEFINITION_CACHE.get(db);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    FILE_DEFINITION_CACHE.set(db, cache);
-  }
-  const cached = cache.get(relativePath);
-  if (cached) {
-    return cached;
-  }
-  const primary = db.all(
-    `SELECT
-      gs.id,
-      gs.symbol,
-      der.document_id,
-      der.start_line,
-      der.end_line,
-      d.relative_path,
-      gs.display_name,
-      gs.kind,
-      gs.documentation,
-      gs.enclosing_symbol
-     FROM global_symbols gs
-     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-     JOIN documents d ON der.document_id = d.id
-     WHERE d.relative_path = ?
-       ${db.symbolNoiseFor("gs")}
-     ORDER BY der.start_line, der.end_line`,
-    relativePath
-  );
-  const fallback = primary.length > 0 ? [] : db.all(
-    `SELECT
-      gs.id,
-      gs.symbol,
-      c.document_id,
-      MIN(c.start_line) AS start_line,
-      MAX(c.end_line) AS end_line,
-      d.relative_path,
-      gs.display_name,
-      gs.kind,
-      gs.documentation,
-      gs.enclosing_symbol
-     FROM global_symbols gs
-     JOIN mentions m ON m.symbol_id = gs.id
-     JOIN chunks c ON m.chunk_id = c.id
-     JOIN documents d ON c.document_id = d.id
-     WHERE d.relative_path = ?
-       AND m.role = 1
-       ${db.symbolNoiseFor("gs")}
-     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path
-     ORDER BY start_line, end_line`,
-    relativePath
-  );
-  const definitions = correctDefinitionRangesFromSource(
-    db,
-    relativePath,
-    (primary.length > 0 ? primary : fallback).map((row) => ({
-      symbolId: row.id,
-      symbol: row.symbol,
-      documentId: row.document_id,
-      startLine: row.start_line,
-      endLine: row.end_line,
-      relativePath: row.relative_path,
-      leaf: leafName(row.symbol),
-      parentTypeName: parentTypeName(row.symbol),
-      isFunctionLike: isFunctionLikeSymbol(row.symbol),
-      isTypeLike: leafSuffix(row.symbol) === "type",
-      kind: row.kind ?? null,
-      documentation: row.documentation ?? null,
-      enclosingSymbol: row.enclosing_symbol ?? null
-    }))
-  );
-  cache.set(relativePath, definitions);
-  return definitions;
-}
-function hydrateSymbolMatch(db, row) {
-  const corrected = getDefinitionsForFile(db, row.relative_path).find((definition) => definition.symbolId === row.id);
-  if (corrected) {
-    return {
-      symbolId: corrected.symbolId,
-      symbol: corrected.symbol,
-      documentId: corrected.documentId,
-      startLine: corrected.startLine,
-      endLine: corrected.endLine,
-      relativePath: corrected.relativePath
-    };
-  }
-  return {
-    symbolId: row.id,
-    symbol: row.symbol,
-    documentId: row.document_id,
-    startLine: row.start_line,
-    endLine: row.end_line,
-    relativePath: row.relative_path
-  };
-}
-function findDirectSymbolCandidate(candidates, symbolPattern, cleanedPattern) {
-  const trimmed = symbolPattern.trim();
-  const directMatches = candidates.filter((row) => {
-    const short = shortenSymbol(row.symbol);
-    const display = (row.display_name ?? "").trim();
-    return row.symbol === trimmed || short === trimmed || short === cleanedPattern || display === trimmed || display === cleanedPattern || `${display}()` === trimmed || row.relative_path === trimmed;
-  });
-  if (directMatches.length === 0) {
-    return null;
-  }
-  directMatches.sort(
-    (left, right) => left.end_line - left.start_line - (right.end_line - right.start_line) || left.relative_path.localeCompare(right.relative_path) || left.symbol.localeCompare(right.symbol)
-  );
-  return directMatches[0] ?? null;
-}
-function correctDefinitionRangesFromSource(db, relativePath, definitions) {
-  const source = getSourceText(db, relativePath);
-  if (!source) {
-    return definitions;
-  }
-  const lines = source.split(/\r?\n/);
-  const correctedStarts = /* @__PURE__ */ new Map();
-  for (const definition of definitions) {
-    correctedStarts.set(
-      definition.symbolId,
-      resolveCallableDefinitionStartLine(lines, definition)
-    );
-  }
-  const correctedRanges = /* @__PURE__ */ new Map();
-  const callableDefinitions = definitions.filter((definition) => isCallableDefinition(definition.symbol)).map((definition) => ({
-    definition,
-    startLine: correctedStarts.get(definition.symbolId) ?? definition.startLine
-  })).sort(
-    (left, right) => left.startLine - right.startLine || left.definition.startLine - right.definition.startLine || left.definition.symbol.localeCompare(right.definition.symbol)
-  );
-  for (let index = 0; index < callableDefinitions.length; index += 1) {
-    const current = callableDefinitions[index];
-    const next = callableDefinitions[index + 1];
-    const maxEndLine = next ? Math.max(current.startLine, next.startLine - 1) : lines.length - 1;
-    correctedRanges.set(current.definition.symbolId, {
-      startLine: current.startLine,
-      endLine: resolveCallableDefinitionEndLine(
-        lines,
-        current.definition,
-        current.startLine,
-        maxEndLine
-      )
-    });
-  }
-  return definitions.map((definition) => {
-    const corrected = correctedRanges.get(definition.symbolId);
-    if (!corrected) {
-      return definition;
-    }
-    return {
-      ...definition,
-      startLine: corrected.startLine,
-      endLine: corrected.endLine
-    };
-  });
-}
-function resolveCallableDefinitionStartLine(lines, definition) {
-  if (!isCallableDefinition(definition.symbol)) {
-    return definition.startLine;
-  }
-  const escapedLeaf = escapeRegex2(definition.leaf);
-  const strongPatterns = [
-    new RegExp(`\\b(?:function|def|fn)\\s+${escapedLeaf}\\b`),
-    new RegExp(`\\b${escapedLeaf}\\b\\s*[:=]\\s*(?:async\\s*)?(?:function\\b|\\()`),
-    // Method/function declaration with optional TypeScript generic
-    // parameters: matches `foo(`, `foo<T>(`, `foo<T = Record<string, unknown>>(`.
-    // `[^(]*` with greedy backtracking handles nested generics as long as
-    // the generic block itself doesn't contain a `(`. Anchored to start of
-    // line content (optional leading whitespace + optional access modifiers)
-    // so it prefers the declaration line over call sites.
-    new RegExp(
-      `^\\s*(?:export\\s+|public\\s+|private\\s+|protected\\s+|static\\s+|readonly\\s+|async\\s+|abstract\\s+|get\\s+|set\\s+)*${escapedLeaf}\\s*(?:<[^(]*>)?\\s*\\(`
-    )
-  ];
-  const fallbackPatterns = [
-    new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`)
-  ];
-  return findNearestMatchingLine(
-    lines,
-    [...strongPatterns, ...fallbackPatterns],
-    definition.startLine,
-    definition.endLine
-  );
-}
-function findNearestMatchingLine(lines, patterns, preferredStartLine, preferredEndLine) {
-  const windowStart = Math.max(0, preferredStartLine - 40);
-  const windowEnd = Math.min(lines.length - 1, Math.max(preferredEndLine + 40, preferredStartLine + 5));
-  const windowMatch = matchNearestLine(lines, patterns, preferredStartLine, windowStart, windowEnd);
-  if (windowMatch !== null) {
-    return windowMatch;
-  }
-  const fullMatch = matchNearestLine(lines, patterns, preferredStartLine, 0, lines.length - 1);
-  return fullMatch ?? Math.max(0, Math.min(preferredStartLine, lines.length - 1));
-}
-function matchNearestLine(lines, patterns, preferredLine, startLine, endLine) {
-  let best = null;
-  for (let lineIndex = startLine; lineIndex <= endLine; lineIndex += 1) {
-    const line = lines[lineIndex] ?? "";
-    if (!patterns.some((pattern) => pattern.test(line))) continue;
-    const distance = Math.abs(lineIndex - preferredLine);
-    if (!best || distance < best.distance) {
-      best = { line: lineIndex, distance };
-    }
-  }
-  return best?.line ?? null;
-}
-function resolveCallableDefinitionEndLine(lines, definition, startLine, maxEndLine) {
-  const boundedEndLine = Math.max(startLine, Math.min(lines.length - 1, maxEndLine));
-  const fallbackEndLine = Math.max(startLine, Math.min(boundedEndLine, definition.endLine));
-  let braceDepth = 0;
-  let parenDepth = 0;
-  let sawOpeningBrace = false;
-  for (let lineIndex = startLine; lineIndex <= boundedEndLine; lineIndex += 1) {
-    const masked = maskStructuralLine(lines[lineIndex] ?? "");
-    for (const char of masked) {
-      if (char === "{") {
-        braceDepth += 1;
-        sawOpeningBrace = true;
-      } else if (char === "}") {
-        braceDepth = Math.max(0, braceDepth - 1);
-      } else if (char === "(") {
-        parenDepth += 1;
-      } else if (char === ")") {
-        parenDepth = Math.max(0, parenDepth - 1);
-      }
-    }
-    if (sawOpeningBrace && braceDepth === 0) {
-      return lineIndex;
-    }
-    if (!sawOpeningBrace && parenDepth === 0 && lineIndex >= fallbackEndLine) {
-      return lineIndex;
-    }
-  }
-  return fallbackEndLine;
-}
-function maskStructuralLine(line) {
-  let masked = "";
-  let quote = null;
-  let escaping = false;
-  for (let index = 0; index < line.length; index += 1) {
-    const char = line[index];
-    const next = line[index + 1];
-    if (!quote && char === "/" && next === "/") {
-      masked += " ".repeat(line.length - index);
-      break;
-    }
-    if (quote) {
-      if (escaping) {
-        escaping = false;
-        masked += " ";
-        continue;
-      }
-      if (char === "\\") {
-        escaping = true;
-        masked += " ";
-        continue;
-      }
-      if (char === quote) {
-        quote = null;
-      }
-      masked += " ";
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      masked += " ";
-      continue;
-    }
-    masked += char;
-  }
-  return masked;
-}
-function isCallableDefinition(symbol) {
-  return symbol.includes("().");
-}
-function escapeRegex2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function getAllDefinitions(db, opts = {}) {
-  const { scope } = opts;
-  const rows = db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-       ${scope ? "AND relative_path LIKE ?" : ""}
-     ORDER BY relative_path`,
-    ...scope ? [`%${scope}%`] : []
-  );
-  return rows.filter((row) => !db.isIgnored(row.relative_path)).flatMap((row) => getDefinitionsForFile(db, row.relative_path));
-}
-function getScopedDefinitions(db, scope) {
-  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-       ${scopeFilter}
-     ORDER BY relative_path`
-  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
-}
-function getAllFunctionLikeDefinitions(db) {
-  return getAllDefinitions(db).filter((definition) => definition.isFunctionLike);
-}
-function resolvePythonCallTarget(db, current, currentFileDefinitions, imports, constructorBindings, receiverName, calleeName) {
-  if (receiverName === "self" || receiverName === "cls") {
-    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
-  }
-  if (receiverName) {
-    const inferredType = constructorBindings.get(receiverName);
-    if (inferredType) {
-      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
-      if (boundMethod) {
-        return boundMethod;
-      }
-      for (const entry of imports) {
-        if (entry.localName !== inferredType || !entry.sourcePath) continue;
-        const importedDefinitions = getDefinitionsForFile(db, entry.sourcePath);
-        const importedMethod = findDefinitionByName(importedDefinitions, calleeName, entry.importedName, ["function"]);
-        if (importedMethod) {
-          return importedMethod;
-        }
-      }
-    }
-    const localClassMethod = findDefinitionByName(currentFileDefinitions, calleeName, receiverName, ["function"]);
-    if (localClassMethod) {
-      return localClassMethod;
-    }
-    const namespaceImport = imports.find((entry) => entry.localName === receiverName && entry.sourcePath);
-    if (namespaceImport?.sourcePath) {
-      const importedDefinitions = getDefinitionsForFile(db, namespaceImport.sourcePath);
-      const importedTypeMethod = namespaceImport.kind === "named" ? findDefinitionByName(importedDefinitions, calleeName, namespaceImport.importedName, ["function"]) : null;
-      if (importedTypeMethod) {
-        return importedTypeMethod;
-      }
-      return findDefinitionByName(importedDefinitions, calleeName, null, ["function", "type"]);
-    }
-    return null;
-  }
-  const importedBinding = imports.find((entry) => entry.localName === calleeName && entry.sourcePath);
-  if (importedBinding?.sourcePath) {
-    const importedDefinitions = getDefinitionsForFile(db, importedBinding.sourcePath);
-    const importedName = importedBinding.importedName === "*" ? calleeName : importedBinding.importedName;
-    const importedDefinition = findDefinitionByName(importedDefinitions, importedName, null, ["function", "type"]);
-    if (importedDefinition) {
-      return importedDefinition;
-    }
-  }
-  return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
-}
-function resolveJavaScriptCallTarget(db, current, currentFileDefinitions, imports, constructorBindings, receiverName, calleeName) {
-  if (receiverName === "this") {
-    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
-  }
-  if (receiverName) {
-    const inferredType = constructorBindings.get(receiverName);
-    if (inferredType) {
-      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
-      if (boundMethod) {
-        return boundMethod;
-      }
-      for (const entry of imports) {
-        if (entry.localName !== inferredType || !entry.sourcePath) continue;
-        const importedDefinitions = getDefinitionsForFile(db, entry.sourcePath);
-        const importedMethod = findDefinitionByName(importedDefinitions, calleeName, entry.importedName, ["function"]);
-        if (importedMethod) {
-          return importedMethod;
-        }
-      }
-    }
-    const localClassMethod = findDefinitionByName(currentFileDefinitions, calleeName, receiverName, ["function"]);
-    if (localClassMethod) {
-      return localClassMethod;
-    }
-    const namespaceImport = imports.find((entry) => entry.localName === receiverName && entry.sourcePath);
-    if (namespaceImport?.sourcePath) {
-      const importedDefinitions = getDefinitionsForFile(db, namespaceImport.sourcePath);
-      if (namespaceImport.kind === "named" || namespaceImport.kind === "default") {
-        const importedTypeMethod = findDefinitionByName(
-          importedDefinitions,
-          calleeName,
-          namespaceImport.importedName,
-          ["function"]
-        );
-        if (importedTypeMethod) {
-          return importedTypeMethod;
-        }
-      }
-      return findDefinitionByName(importedDefinitions, calleeName, null, ["function", "type"]);
-    }
-    return null;
-  }
-  const importedBinding = imports.find((entry) => entry.localName === calleeName && entry.sourcePath && entry.kind !== "namespace");
-  if (importedBinding?.sourcePath) {
-    const importedDefinitions = getDefinitionsForFile(db, importedBinding.sourcePath);
-    const importedName = importedBinding.importedName === "default" ? importedBinding.localName ?? calleeName : importedBinding.importedName;
-    const importedDefinition = findDefinitionByName(importedDefinitions, importedName, null, ["function", "type"]);
-    if (importedDefinition) {
-      return importedDefinition;
-    }
-  }
-  return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
-}
-function resolveSimpleSourceCallees(db, current, calls, bindings, limit) {
-  const currentFileDefinitions = getDefinitionsForFile(db, current.relativePath);
-  const currentDefinition = currentFileDefinitions.find((definition) => definition.symbolId === current.symbolId);
-  if (!currentDefinition) {
-    return [];
-  }
-  const rows = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const call of calls) {
-    const resolved = resolveSimpleSourceCallTarget(
-      db,
-      currentDefinition,
-      currentFileDefinitions,
-      bindings,
-      call.receiverName,
-      call.calleeName
-    );
-    if (!resolved || resolved.symbolId === current.symbolId || db.isIgnored(resolved.relativePath)) continue;
-    const chunkId = 2e9 + call.line;
-    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    rows.push({
-      symbol: resolved.symbol,
-      file: resolved.relativePath,
-      chunkId
-    });
-  }
-  return applyLimit(rows, limit);
-}
-function resolveSimpleSourceCallTarget(db, current, currentFileDefinitions, bindings, receiverName, calleeName) {
-  if (!receiverName) {
-    const localMethod = findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
-    if (localMethod) {
-      return localMethod;
-    }
-    if (current.parentTypeName) {
-      return findProjectDefinitionByTypeAndLeaf(db, current.parentTypeName, calleeName);
-    }
-    return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
-  }
-  const normalizedReceiver = normalizeReceiverName(receiverName);
-  const inferredType = bindings.get(normalizedReceiver) ?? inferTypeNameFromReceiver(db, normalizedReceiver);
-  if (!inferredType) {
-    return null;
-  }
-  return findProjectDefinitionByTypeAndLeaf(db, inferredType, calleeName);
-}
-function findProjectDefinitionByTypeAndLeaf(db, typeName, calleeName) {
-  const definitions = getAllDefinitions(db).filter((definition) => definition.isFunctionLike || definition.symbol.endsWith("()."));
-  const exact = definitions.find((definition) => definition.leaf === calleeName && (definition.parentTypeName === typeName || definition.symbol.includes(typeName)));
-  if (exact) {
-    return exact;
-  }
-  const normalizedType = normalizeLookupName(typeName);
-  const normalizedMatch = definitions.find((definition) => definition.leaf === calleeName && normalizeLookupName(definition.parentTypeName ?? "").includes(normalizedType));
-  if (normalizedMatch) {
-    return normalizedMatch;
-  }
-  return findLooseProjectDefinitionByTypeAndLeaf(db, typeName, calleeName);
-}
-function inferTypeNameFromReceiver(db, receiverName) {
-  const normalizedReceiver = normalizeLookupName(receiverName);
-  if (!normalizedReceiver) {
-    return null;
-  }
-  const candidates = getAllDefinitions(db).filter((definition) => definition.isTypeLike || definition.symbol.endsWith("#")).map((definition) => definition.leaf).filter((leaf) => leaf.length > 0);
-  let best = null;
-  for (const candidate of candidates) {
-    const normalizedCandidate = normalizeLookupName(candidate);
-    let score = 0;
-    if (normalizedCandidate === normalizedReceiver) score += 100;
-    if (normalizedCandidate.endsWith(normalizedReceiver)) score += 80;
-    if (normalizedCandidate.includes(normalizedReceiver)) score += 40;
-    if (normalizedReceiver.includes(normalizedCandidate)) score += 20;
-    if (score > 0 && (!best || score > best.score || score === best.score && candidate.length < best.name.length)) {
-      best = { name: candidate, score };
-    }
-  }
-  return best?.name ?? null;
-}
-function getSimpleSourceCalls(db, relativePath, startLine, endLine, opts = {}) {
-  const source = getSourceText(db, relativePath);
-  if (!source) {
-    return [];
-  }
-  const lines = source.split("\n");
-  const scoped = lines.slice(startLine, endLine + 1);
-  const calls = [];
-  const seen = /* @__PURE__ */ new Set();
-  const pattern = opts.allowInstanceVariables ? /(@?[A-Za-z_][\w]*)\s*(?:\.|::)\s*([A-Za-z_][\w!?=]*)\s*\(/g : /\b([A-Za-z_][\w]*)\s*(?:\.|::)\s*([A-Za-z_][\w]*)\s*\(/g;
-  for (let index = 0; index < scoped.length; index++) {
-    const rawLine = scoped[index] ?? "";
-    for (const match of rawLine.matchAll(pattern)) {
-      const receiverName = match[1];
-      const calleeName = match[2];
-      if (!receiverName || !calleeName) continue;
-      const key = `${startLine + index}|${receiverName}|${calleeName}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      calls.push({
-        receiverName,
-        calleeName,
-        line: startLine + index
-      });
-    }
-    if (opts.allowBareMemberCalls) {
-      for (const match of rawLine.matchAll(/(@?[A-Za-z_][\w]*)\s*\.\s*([A-Za-z_][\w!?=]*)\b(?!\s*[:=])/g)) {
-        const receiverName = match[1];
-        const calleeName = match[2];
-        if (!receiverName || !calleeName) continue;
-        const key = `${startLine + index}|${receiverName}|${calleeName}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        calls.push({
-          receiverName,
-          calleeName,
-          line: startLine + index
-        });
-      }
-    }
-    for (const match of rawLine.matchAll(/\b([A-Za-z_][\w]*)\s*\(/g)) {
-      const calleeName = match[1];
-      const start = match.index ?? -1;
-      if (!calleeName || start < 0) continue;
-      const prefix = rawLine.slice(0, start).trimEnd();
-      if (prefix.endsWith("def") || prefix.endsWith("fun") || prefix.endsWith("fn") || /\b(?:class|interface|trait|module|object)\s*$/.test(prefix)) {
-        continue;
-      }
-      if (rawLine.slice(Math.max(0, start - 3), start).includes(".")) {
-        continue;
-      }
-      calls.push({
-        receiverName: null,
-        calleeName,
-        line: startLine + index
-      });
-    }
-  }
-  return calls;
-}
-function parseJavaFieldBindings(source) {
-  const bindings = /* @__PURE__ */ new Map();
-  for (const match of source.matchAll(/\b(?:private|protected|public)\s+(?:final\s+)?([A-Z][A-Za-z0-9_$<>?, ]*)\s+([A-Za-z_][\w$]*)\s*;/g)) {
-    const typeName = stripGenericType(match[1]);
-    const localName = match[2];
-    if (typeName && localName) {
-      bindings.set(localName, typeName);
-    }
-  }
-  return bindings;
-}
-function parseKotlinFieldBindings(source) {
-  const bindings = /* @__PURE__ */ new Map();
-  for (const match of source.matchAll(/\b(?:private|protected|public)?\s*(?:val|var)\s+([A-Za-z_][\w]*)\s*:\s*([A-Z][A-Za-z0-9_.<>?]*)/g)) {
-    const localName = match[1];
-    const typeName = stripGenericType(match[2]);
-    if (typeName && localName) {
-      bindings.set(localName, typeName);
-    }
-  }
-  return bindings;
-}
-function parseCppReceiverBindings(source) {
-  const bindings = /* @__PURE__ */ new Map();
-  const constructorMatch = source.match(/RunCoordinator::RunCoordinator\s*\(([\s\S]*?)\)\s*(?::\s*([\s\S]*?))?\s*\{/);
-  if (!constructorMatch) {
-    return bindings;
-  }
-  const params = constructorMatch[1] ?? "";
-  const initializers = constructorMatch[2] ?? "";
-  const parameterTypes = /* @__PURE__ */ new Map();
-  for (const param of params.split(",")) {
-    const trimmed = param.trim();
-    const match = trimmed.match(/(.+?)\s+([A-Za-z_][\w]*)$/);
-    if (!match) continue;
-    const [, rawType, rawName] = match;
-    if (!rawType || !rawName) continue;
-    const typeName = stripGenericType(rawType.replace(/[&*]+/g, " ").replace(/\bconst\b/g, " ").trim());
-    if (!typeName) continue;
-    parameterTypes.set(normalizeReceiverName(rawName), typeName);
-  }
-  for (const initializer of initializers.split(",")) {
-    const trimmed = initializer.trim();
-    const match = trimmed.match(/([A-Za-z_][\w]*)\s*\(\s*([A-Za-z_][\w]*)\s*\)$/);
-    if (!match) continue;
-    const [, fieldName, sourceName] = match;
-    if (!fieldName || !sourceName) continue;
-    const typeName = parameterTypes.get(normalizeReceiverName(sourceName));
-    if (!typeName) continue;
-    bindings.set(normalizeReceiverName(fieldName), typeName);
-  }
-  return bindings;
-}
-function parseRubyReceiverBindings(db, source) {
-  const bindings = /* @__PURE__ */ new Map();
-  for (const match of source.matchAll(/@([A-Za-z_][\w]*)\s*=\s*([A-Za-z_][\w]*)/g)) {
-    const ivarName = `@${match[1]}`;
-    const localName = match[2];
-    const typeName = inferTypeNameFromReceiver(db, localName ?? match[1] ?? "");
-    if (typeName) {
-      bindings.set(ivarName, typeName);
-      bindings.set(match[1], typeName);
-    }
-  }
-  return bindings;
-}
-function stripGenericType(typeName) {
-  return (typeName ?? "").replace(/<.*$/, "").replace(/^.*\./, "").trim();
-}
-function normalizeReceiverName(receiverName) {
-  return receiverName.replace(/^@/, "").replace(/^this(?:\.|->)/, "").replace(/^_+/, "").replace(/_+$/, "").trim();
-}
-function normalizeLookupName(value) {
-  return value.replace(/[^A-Za-z0-9]+/g, "").toLowerCase();
-}
-function isLikelyTestPath(relativePath) {
-  return /(^|\/)(tests?|__tests__)\//.test(relativePath) || /\.(?:spec|test)\./.test(relativePath) || /_test\./.test(relativePath);
-}
-function findDefinitionByName(definitions, leaf, parentType, preference) {
-  const candidates = definitions.filter((definition) => definition.leaf === leaf && definition.parentTypeName === parentType);
-  if (candidates.length === 0) {
-    return null;
-  }
-  for (const preferred of preference) {
-    const match = candidates.find((candidate) => preferred === "function" ? candidate.isFunctionLike : candidate.isTypeLike);
-    if (match) {
-      return match;
-    }
-  }
-  return candidates[0] ?? null;
-}
-function findLooseProjectDefinitionByTypeAndLeaf(db, typeName, calleeName) {
-  const rows = db.all(
-    `SELECT
-      gs.id,
-      gs.symbol,
-      c.document_id,
-      MIN(c.start_line) AS start_line,
-      MAX(c.end_line) AS end_line,
-      d.relative_path,
-      gs.kind,
-      gs.documentation,
-      gs.enclosing_symbol
-     FROM global_symbols gs
-     JOIN mentions m ON m.symbol_id = gs.id
-     JOIN chunks c ON c.id = m.chunk_id
-     JOIN documents d ON d.id = c.document_id
-     WHERE gs.symbol LIKE ?
-       AND gs.symbol LIKE ?
-       ${db.pathExclusionsFor("d")}
-     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path, gs.kind, gs.documentation, gs.enclosing_symbol`,
-    `%${typeName}%`,
-    `%${calleeName}%`
-  );
-  const normalizedType = normalizeLookupName(typeName);
-  const candidates = rows.filter((row2) => leafName(row2.symbol) === calleeName).filter((row2) => {
-    const parentType = parentTypeName(row2.symbol);
-    return parentType === typeName || row2.symbol.includes(typeName) || normalizeLookupName(parentType ?? "").includes(normalizedType);
-  }).sort((left, right) => {
-    const leftTest = isLikelyTestPath(left.relative_path) ? 1 : 0;
-    const rightTest = isLikelyTestPath(right.relative_path) ? 1 : 0;
-    return leftTest - rightTest || left.relative_path.localeCompare(right.relative_path) || left.start_line - right.start_line;
-  });
-  const row = candidates[0];
-  if (!row) {
-    return null;
-  }
-  return {
-    symbolId: row.id,
-    symbol: row.symbol,
-    documentId: row.document_id,
-    startLine: row.start_line,
-    endLine: row.end_line,
-    relativePath: row.relative_path,
-    leaf: leafName(row.symbol),
-    parentTypeName: parentTypeName(row.symbol),
-    isFunctionLike: isFunctionLikeSymbol(row.symbol),
-    isTypeLike: leafSuffix(row.symbol) === "type",
-    kind: row.kind,
-    documentation: row.documentation,
-    enclosingSymbol: row.enclosing_symbol
-  };
-}
-function hasUniqueLeafDefinition(db, leaf, symbolId) {
-  const rows = db.all(
-    `SELECT id, symbol
-     FROM global_symbols
-     WHERE symbol LIKE ?
-     LIMIT 50`,
-    `%${leaf}%`
-  );
-  let count = 0;
-  for (const row of rows) {
-    if (leafName(row.symbol) !== leaf) continue;
-    count++;
-    if (count > 1 && row.id !== symbolId) {
-      return false;
-    }
-  }
-  return count === 1;
-}
-function parentTypeName(rawSymbol) {
-  const parsed = parseSymbol(rawSymbol);
-  if ("kind" in parsed) {
-    return null;
-  }
-  for (let index = parsed.descriptors.length - 2; index >= 0; index--) {
-    const descriptor = parsed.descriptors[index];
-    if (descriptor?.suffix === "type") {
-      return descriptor.name;
-    }
-  }
-  return null;
-}
-var DOCUMENT_LANGUAGE_TABLE = [
-  { languages: ["python"], extensionPattern: /\.(?:py|pyi)$/ },
-  { languages: ["typescript", "javascript"], extensionPattern: /\.(?:[cm]?[jt]sx?)$/ },
-  { languages: ["java"], extensionPattern: /\.java$/ },
-  { languages: ["kotlin"], extensionPattern: /\.(?:kt|kts)$/ },
-  { languages: ["scala"], extensionPattern: /\.scala$/ },
-  { languages: ["C#"], extensionPattern: /\.cs$/ },
-  { languages: ["Visual Basic"], extensionPattern: /\.vb$/ },
-  { languages: ["CPP"], extensionPattern: /\.(?:cc|cpp|cxx|hpp|hh|hxx)$/ },
-  { languages: ["Rust"], extensionPattern: /\.rs$/ },
-  { languages: ["ruby"], extensionPattern: /\.rb$/ },
-  { languages: ["Dart"], extensionPattern: /\.dart$/ },
-  { languages: ["PHP"], extensionPattern: /\.php$/ }
-];
-function isDocumentLanguage(db, relativePath, entry) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return entry.languages.includes(row?.language ?? "") || entry.extensionPattern.test(relativePath);
-}
-function isPythonDocument(db, relativePath) {
-  return isDocumentLanguage(db, relativePath, DOCUMENT_LANGUAGE_TABLE[0]);
-}
-function applyLimit(values, limit) {
-  return typeof limit === "number" ? values.slice(0, limit) : values;
-}
-function resolveDocumentCandidates(db, filePattern, opts) {
-  const normalizedPattern = normalizeLookupPath(filePattern);
-  if (!normalizedPattern) {
-    return [];
-  }
-  const rows = db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-     ORDER BY relative_path`
-  );
-  const scored = rows.filter((row) => !db.isIgnored(row.relative_path)).map((row) => ({
-    relativePath: row.relative_path,
-    score: scoreDocumentPath(row.relative_path, normalizedPattern)
-  })).filter((row) => row.score > 0).sort((a, b) => b.score - a.score || a.relativePath.localeCompare(b.relativePath));
-  if (scored.length === 0) {
-    const symbolMatch = findFirstSymbolMatch(db, filePattern);
-    if (!symbolMatch || db.isIgnored(symbolMatch.relativePath)) {
-      return [];
-    }
-    return [{
-      relativePath: symbolMatch.relativePath,
-      score: 700
-    }];
-  }
-  const exactish = scored.filter((row) => row.score >= 800);
-  if (exactish.length > 0) {
-    return opts.allowMultiple ? exactish : [exactish[0]];
-  }
-  return opts.allowMultiple ? scored : [scored[0]];
-}
-function scoreDocumentPath(relativePath, rawPattern) {
-  const normalizedPath = normalizeLookupPath(relativePath);
-  const pathBase = basename2(normalizedPath);
-  const patternBase = basename2(rawPattern);
-  let score = 0;
-  if (normalizedPath === rawPattern) score += 1200;
-  if (normalizedPath.endsWith(`/${rawPattern}`)) score += 1100;
-  if (pathBase === patternBase) score += 900;
-  if (normalizedPath.startsWith(`${rawPattern}/`)) score += 850;
-  if (normalizedPath.includes(rawPattern)) score += 250;
-  return score;
-}
-function normalizeLookupPath(filePattern) {
-  return filePattern.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
-}
-
-export {
-  getSourceImports,
-  getSourceExports,
-  getSourceText,
-  TEST_FILE_PATTERNS,
-  TEST_SUPPORT_PATH_PATTERNS,
-  buildFileDepGraph,
-  findFirstSymbolMatch,
-  findExactSymbolMatch,
-  resolveIndexedFile,
-  resolveIndexedPaths,
-  getCalleeRowsForSymbol,
-  getCallerRowsForSymbol,
-  getSourceReferenceSites,
-  getResolvedReferenceSites,
-  findEnclosingDefinition,
-  getDefinitionsForFile,
-  getAllDefinitions,
-  getScopedDefinitions
-};
-//# sourceMappingURL=chunk-OMCRXXDX.js.map