scip-query 0.3.5 → 0.4.1

package/dist/chunk-ALUFWH3U.js

@@ -0,0 +1,2695 @@
+import {
+  isFunctionLikeSymbol,
+  isModuleLikeSymbol,
+  leafName,
+  leafSuffix,
+  parseSymbol,
+  shortenSymbol
+} from "./chunk-TO3L4YNK.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, "/");
+}
+function isJavaScriptSourcePath(relativePath) {
+  return SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isPythonSourcePath(relativePath) {
+  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isJvmSourcePath(relativePath) {
+  return JVM_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isRustSourcePath(relativePath) {
+  return RUST_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isRubySourcePath(relativePath) {
+  return RUBY_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isCLikeSourcePath(relativePath) {
+  return C_LIKE_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isDotNetSourcePath(relativePath) {
+  return DOTNET_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isVisualBasicSourcePath(relativePath) {
+  return extname(relativePath).toLowerCase() === ".vb";
+}
+function isDartSourcePath(relativePath) {
+  return DART_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isPhpSourcePath(relativePath) {
+  return PHP_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function extensionFamilyFor(relativePath) {
+  if (isJvmSourcePath(relativePath)) return JVM_SOURCE_EXTENSIONS;
+  if (isDotNetSourcePath(relativePath)) return DOTNET_SOURCE_EXTENSIONS;
+  if (isPhpSourcePath(relativePath)) return PHP_SOURCE_EXTENSIONS;
+  if (isDartSourcePath(relativePath)) return DART_SOURCE_EXTENSIONS;
+  if (isCLikeSourcePath(relativePath)) return C_LIKE_SOURCE_EXTENSIONS;
+  if (isRustSourcePath(relativePath)) return RUST_SOURCE_EXTENSIONS;
+  if (isRubySourcePath(relativePath)) return RUBY_SOURCE_EXTENSIONS;
+  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 testFileExclusionSql(alias, extraPatterns = []) {
+  const patterns = uniquePatterns([...TEST_FILE_PATTERNS, ...extraPatterns]);
+  return patterns.map((pattern) => `${alias}.relative_path NOT LIKE '${pattern}'`).join("\n      AND ");
+}
+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;
+    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}%`,
+      parseInt(startStr, 10),
+      parseInt(endStr, 10)
+    );
+    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}%`,
+        parseInt(startStr, 10),
+        parseInt(endStr, 10)
+      );
+    }
+    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 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;
+}
+function getPythonSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isPythonDocument(db, match.relativePath)) {
+    return [];
+  }
+  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 = resolvePythonCallTarget(
+      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 getJavaScriptSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isJavaScriptDocument(db, match.relativePath)) {
+    return [];
+  }
+  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 = resolveJavaScriptCallTarget(
+      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 getJavaSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isJavaDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  const bindings = parseJavaFieldBindings(getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
+}
+function getKotlinSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isKotlinDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  const bindings = parseKotlinFieldBindings(getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
+}
+function getScalaSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isScalaDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getCSharpSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isCSharpDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getVisualBasicSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isVisualBasicDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getCppSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isCppDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  const bindings = parseCppReceiverBindings(getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
+}
+function getRustSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isRustDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getRubySourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isRubyDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, { allowInstanceVariables: true });
+  const rubyCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, {
+    allowInstanceVariables: true,
+    allowBareMemberCalls: true
+  });
+  const bindings = parseRubyReceiverBindings(db, getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, rubyCalls.length > 0 ? rubyCalls : calls, bindings, limit);
+}
+function getDartSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isDartDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getPhpSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isPhpDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getSourceBackedCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
+  }
+  if (isPythonDocument(db, match.relativePath)) {
+    return getPythonSourceCalleeRows(db, match, limit);
+  }
+  if (isJavaScriptDocument(db, match.relativePath)) {
+    return getJavaScriptSourceCalleeRows(db, match, limit);
+  }
+  if (isJavaDocument(db, match.relativePath)) {
+    return getJavaSourceCalleeRows(db, match, limit);
+  }
+  if (isScalaDocument(db, match.relativePath)) {
+    return getScalaSourceCalleeRows(db, match, limit);
+  }
+  if (isKotlinDocument(db, match.relativePath)) {
+    return getKotlinSourceCalleeRows(db, match, limit);
+  }
+  if (isCSharpDocument(db, match.relativePath)) {
+    return getCSharpSourceCalleeRows(db, match, limit);
+  }
+  if (isVisualBasicDocument(db, match.relativePath)) {
+    return getVisualBasicSourceCalleeRows(db, match, limit);
+  }
+  if (isCppDocument(db, match.relativePath)) {
+    return getCppSourceCalleeRows(db, match, limit);
+  }
+  if (isRustDocument(db, match.relativePath)) {
+    return getRustSourceCalleeRows(db, match, limit);
+  }
+  if (isRubyDocument(db, match.relativePath)) {
+    return getRubySourceCalleeRows(db, match, limit);
+  }
+  if (isDartDocument(db, match.relativePath)) {
+    return getDartSourceCalleeRows(db, match, limit);
+  }
+  if (isPhpDocument(db, match.relativePath)) {
+    return getPhpSourceCalleeRows(db, match, limit);
+  }
+  return [];
+}
+function getPythonSourceCallerRows(db, target, limit) {
+  if (!isPythonDocument(db, target.relativePath)) {
+    return [];
+  }
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of getAllFunctionLikeDefinitions(db)) {
+    if (candidate.symbolId === target.symbolId) continue;
+    const callees = getPythonSourceCalleeRows(db, candidate);
+    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|\\()`)
+  ];
+  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 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;
+}
+function isPythonDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "python" || relativePath.endsWith(".py") || relativePath.endsWith(".pyi");
+}
+function isJavaScriptDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "typescript" || row?.language === "javascript" || /\.(?:[cm]?[jt]sx?)$/.test(relativePath);
+}
+function isJavaDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "java" || relativePath.endsWith(".java");
+}
+function isKotlinDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "kotlin" || relativePath.endsWith(".kt") || relativePath.endsWith(".kts");
+}
+function isScalaDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "scala" || relativePath.endsWith(".scala");
+}
+function isCSharpDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "C#" || relativePath.endsWith(".cs");
+}
+function isVisualBasicDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "Visual Basic" || relativePath.endsWith(".vb");
+}
+function isCppDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "CPP" || /\.(?:cc|cpp|cxx|hpp|hh|hxx)$/.test(relativePath);
+}
+function isRustDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "Rust" || relativePath.endsWith(".rs");
+}
+function isRubyDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "ruby" || relativePath.endsWith(".rb");
+}
+function isDartDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "Dart" || relativePath.endsWith(".dart");
+}
+function isPhpDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "PHP" || relativePath.endsWith(".php");
+}
+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(/\/+$/, "");
+}
+function uniquePatterns(patterns) {
+  return [...new Set(patterns)];
+}
+
+export {
+  getSourceImports,
+  getSourceExports,
+  getSourceText,
+  TEST_FILE_PATTERNS,
+  TEST_SUPPORT_PATH_PATTERNS,
+  testFileExclusionSql,
+  buildFileDepGraph,
+  findFirstSymbolMatch,
+  findExactSymbolMatch,
+  resolveIndexedFile,
+  resolveIndexedPaths,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol,
+  getSourceReferenceSites,
+  getDefinitionsForFile,
+  getAllDefinitions
+};
+//# sourceMappingURL=chunk-ALUFWH3U.js.map