scip-query 0.4.2 → 0.5.0

package/dist/{chunk-ALUFWH3U.js → chunk-OMCRXXDX.js}

@@ -5,7 +5,7 @@ import {
   leafSuffix,
   parseSymbol,
   shortenSymbol
-} from "./chunk-TO3L4YNK.js";
+} from "./chunk-YMSJCSRG.js";
 
 // src/source-analysis.ts
 import {
@@ -1054,44 +1054,55 @@ function getCachedMap(cache, db) {
 function normalizePath(path) {
   return path.replace(/\\/g, "/");
 }
+var LANGUAGE_EXTENSION_FAMILIES = [
+  SOURCE_EXTENSIONS,
+  PYTHON_SOURCE_EXTENSIONS,
+  JVM_SOURCE_EXTENSIONS,
+  RUST_SOURCE_EXTENSIONS,
+  RUBY_SOURCE_EXTENSIONS,
+  C_LIKE_SOURCE_EXTENSIONS,
+  DOTNET_SOURCE_EXTENSIONS,
+  DART_SOURCE_EXTENSIONS,
+  PHP_SOURCE_EXTENSIONS
+];
+function hasExtensionIn(relativePath, extensions) {
+  return extensions.includes(extname(relativePath).toLowerCase());
+}
 function isJavaScriptSourcePath(relativePath) {
-  return SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, SOURCE_EXTENSIONS);
 }
 function isPythonSourcePath(relativePath) {
-  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, PYTHON_SOURCE_EXTENSIONS);
 }
 function isJvmSourcePath(relativePath) {
-  return JVM_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, JVM_SOURCE_EXTENSIONS);
 }
 function isRustSourcePath(relativePath) {
-  return RUST_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, RUST_SOURCE_EXTENSIONS);
 }
 function isRubySourcePath(relativePath) {
-  return RUBY_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, RUBY_SOURCE_EXTENSIONS);
 }
 function isCLikeSourcePath(relativePath) {
-  return C_LIKE_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, C_LIKE_SOURCE_EXTENSIONS);
 }
 function isDotNetSourcePath(relativePath) {
-  return DOTNET_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, DOTNET_SOURCE_EXTENSIONS);
 }
 function isVisualBasicSourcePath(relativePath) {
   return extname(relativePath).toLowerCase() === ".vb";
 }
 function isDartSourcePath(relativePath) {
-  return DART_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, DART_SOURCE_EXTENSIONS);
 }
 function isPhpSourcePath(relativePath) {
-  return PHP_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, PHP_SOURCE_EXTENSIONS);
 }
 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;
+  const ext = extname(relativePath).toLowerCase();
+  for (const family of LANGUAGE_EXTENSION_FAMILIES) {
+    if (family.includes(ext)) return family;
+  }
   return SOURCE_EXTENSIONS;
 }
 function getSourceText(db, relativePath) {
@@ -1139,10 +1150,6 @@ var TEST_FILE_PATTERNS = [
 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(
@@ -1197,6 +1204,8 @@ function findFirstSymbolMatch(db, symbolPattern) {
   const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
   if (fileLineMatch) {
     const [, filePath, startStr, endStr] = fileLineMatch;
+    const userStart0 = Math.max(0, parseInt(startStr, 10) - 1);
+    const userEnd0 = Math.max(userStart0, parseInt(endStr, 10) - 1);
     let row = db.get(
       `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
       FROM global_symbols gs
@@ -1208,8 +1217,8 @@ function findFirstSymbolMatch(db, symbolPattern) {
       ORDER BY (der.end_line - der.start_line) ASC
         LIMIT 1`,
       `%${filePath}%`,
-      parseInt(startStr, 10),
-      parseInt(endStr, 10)
+      userStart0,
+      userEnd0
     );
     if (!row) {
       row = db.get(
@@ -1226,8 +1235,8 @@ function findFirstSymbolMatch(db, symbolPattern) {
          ORDER BY (MAX(c.end_line) - MIN(c.start_line)) ASC
          LIMIT 1`,
         `%${filePath}%`,
-        parseInt(startStr, 10),
-        parseInt(endStr, 10)
+        userStart0,
+        userEnd0
       );
     }
     if (row && !db.isIgnored(row.relative_path)) {
@@ -1519,6 +1528,59 @@ function getSourceReferenceSites(db, symbol) {
   }
   return sites;
 }
+function getResolvedReferenceSites(db, symbol) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT DISTINCT d.relative_path, c.start_line, c.end_line
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.symbol_id = ?
+       AND m.role != 1
+       ${db.pathExclusionsFor("d")}
+     ORDER BY d.relative_path, c.start_line`,
+    match.symbolId
+  );
+  const chunksByFile = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    let bucket = chunksByFile.get(row.relative_path);
+    if (!bucket) {
+      bucket = [];
+      chunksByFile.set(row.relative_path, bucket);
+    }
+    bucket.push({ start_line: row.start_line, end_line: row.end_line });
+  }
+  const identifier = leafName(match.symbol);
+  const sites = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [file, chunks] of chunksByFile) {
+    const definitions = getDefinitionsForFile(db, file);
+    const excludeOpts = file === match.relativePath ? { excludeStartLine: match.startLine, excludeEndLine: match.endLine } : {};
+    const allHits = identifier ? findIdentifierLines(db, file, identifier, excludeOpts) : [];
+    for (const chunk of chunks) {
+      const hitsInChunk = allHits.filter(
+        (line) => line >= chunk.start_line && line <= chunk.end_line
+      );
+      const lines = hitsInChunk.length > 0 ? hitsInChunk : [chunk.start_line];
+      for (const line of lines) {
+        const enclosing = findEnclosingDefinition(definitions, line);
+        const key = `${file}|${line}|${enclosing?.symbol ?? ""}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        sites.push({
+          file,
+          line,
+          enclosingSymbol: enclosing?.symbol ?? null
+        });
+      }
+    }
+  }
+  return sites;
+}
 function calleeQueryParams(symbol, limit) {
   const params = [
     symbol.documentId,
@@ -1548,56 +1610,41 @@ function findEnclosingDefinition(definitions, line) {
   }
   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 [];
-  }
+var LANGUAGE_CALLEE_CONFIGS = [
+  // Python (index 0) — complex resolver
+  { kind: "complex", languageIndex: 0, resolver: resolvePythonCallTarget },
+  // JavaScript/TypeScript (index 1) — complex resolver
+  { kind: "complex", languageIndex: 1, resolver: resolveJavaScriptCallTarget },
+  // Java (index 2) — simple with field bindings
+  { kind: "simple", languageIndex: 2, parseBindings: (_db, source) => parseJavaFieldBindings(source) },
+  // Kotlin (index 3) — simple with field bindings
+  { kind: "simple", languageIndex: 3, parseBindings: (_db, source) => parseKotlinFieldBindings(source) },
+  // Scala (index 4) — simple, no bindings
+  { kind: "simple", languageIndex: 4, parseBindings: null },
+  // C# (index 5) — simple, no bindings
+  { kind: "simple", languageIndex: 5, parseBindings: null },
+  // Visual Basic (index 6) — simple, no bindings
+  { kind: "simple", languageIndex: 6, parseBindings: null },
+  // C++ (index 7) — simple with receiver bindings
+  { kind: "simple", languageIndex: 7, parseBindings: (_db, source) => parseCppReceiverBindings(source) },
+  // Rust (index 8) — simple, no bindings
+  { kind: "simple", languageIndex: 8, parseBindings: null },
+  // Ruby (index 9) — simple with dual-attempt logic
+  {
+    kind: "simple",
+    languageIndex: 9,
+    parseBindings: (db, source) => parseRubyReceiverBindings(db, source),
+    dualAttempt: {
+      baseOpts: { allowInstanceVariables: true },
+      extendedOpts: { allowInstanceVariables: true, allowBareMemberCalls: true }
+    }
+  },
+  // Dart (index 10) — simple, no bindings
+  { kind: "simple", languageIndex: 10, parseBindings: null },
+  // PHP (index 11) — simple, no bindings
+  { kind: "simple", languageIndex: 11, parseBindings: null }
+];
+function getComplexSourceCalleeRows(db, match, config, limit) {
   const definitions = getDefinitionsForFile(db, match.relativePath);
   const current = definitions.find((definition) => definition.symbolId === match.symbolId);
   if (!current) {
@@ -1616,7 +1663,7 @@ function getJavaScriptSourceCalleeRows(db, symbol, limit) {
     startLine: match.startLine,
     endLine: match.endLine
   })) {
-    const resolved = resolveJavaScriptCallTarget(
+    const resolved = config.resolver(
       db,
       current,
       definitions,
@@ -1638,134 +1685,31 @@ function getJavaScriptSourceCalleeRows(db, symbol, limit) {
   }
   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 [];
+function getSimpleLanguageCalleeRows(db, match, config, limit) {
+  let calls;
+  if (config.dualAttempt) {
+    const baseCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.dualAttempt.baseOpts);
+    const extendedCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.dualAttempt.extendedOpts);
+    calls = extendedCalls.length > 0 ? extendedCalls : baseCalls;
+  } else {
+    calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.sourceCallOpts);
   }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  const bindings = parseCppReceiverBindings(getSourceText(db, match.relativePath));
+  const bindings = config.parseBindings ? config.parseBindings(db, getSourceText(db, match.relativePath)) : /* @__PURE__ */ new Map();
   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);
+  for (const config of LANGUAGE_CALLEE_CONFIGS) {
+    if (!isDocumentLanguage(db, match.relativePath, DOCUMENT_LANGUAGE_TABLE[config.languageIndex])) {
+      continue;
+    }
+    if (config.kind === "complex") {
+      return getComplexSourceCalleeRows(db, match, config, limit);
+    }
+    return getSimpleLanguageCalleeRows(db, match, config, limit);
   }
   return [];
 }
@@ -1775,9 +1719,11 @@ function getPythonSourceCallerRows(db, target, limit) {
   }
   const rows = [];
   const seen = /* @__PURE__ */ new Set();
+  const pythonConfig = LANGUAGE_CALLEE_CONFIGS[0];
   for (const candidate of getAllFunctionLikeDefinitions(db)) {
     if (candidate.symbolId === target.symbolId) continue;
-    const callees = getPythonSourceCalleeRows(db, candidate);
+    if (!isDocumentLanguage(db, candidate.relativePath, DOCUMENT_LANGUAGE_TABLE[pythonConfig.languageIndex])) continue;
+    const callees = getComplexSourceCalleeRows(db, candidate, pythonConfig);
     if (!callees.some((callee) => callee.symbol === target.symbol)) continue;
     const key = `${candidate.symbol}|${candidate.relativePath}`;
     if (seen.has(key) || db.isIgnored(candidate.relativePath)) continue;
@@ -2000,7 +1946,16 @@ function resolveCallableDefinitionStartLine(lines, definition) {
   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|\\()`)
+    new RegExp(`\\b${escapedLeaf}\\b\\s*[:=]\\s*(?:async\\s*)?(?:function\\b|\\()`),
+    // Method/function declaration with optional TypeScript generic
+    // parameters: matches `foo(`, `foo<T>(`, `foo<T = Record<string, unknown>>(`.
+    // `[^(]*` with greedy backtracking handles nested generics as long as
+    // the generic block itself doesn't contain a `(`. Anchored to start of
+    // line content (optional leading whitespace + optional access modifiers)
+    // so it prefers the declaration line over call sites.
+    new RegExp(
+      `^\\s*(?:export\\s+|public\\s+|private\\s+|protected\\s+|static\\s+|readonly\\s+|async\\s+|abstract\\s+|get\\s+|set\\s+)*${escapedLeaf}\\s*(?:<[^(]*>)?\\s*\\(`
+    )
   ];
   const fallbackPatterns = [
     new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`)
@@ -2119,6 +2074,17 @@ function getAllDefinitions(db, opts = {}) {
   );
   return rows.filter((row) => !db.isIgnored(row.relative_path)).flatMap((row) => getDefinitionsForFile(db, row.relative_path));
 }
+function getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
 function getAllFunctionLikeDefinitions(db) {
   return getAllDefinitions(db).filter((definition) => definition.isFunctionLike);
 }
@@ -2536,89 +2502,29 @@ function parentTypeName(rawSymbol) {
   }
   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) {
+var DOCUMENT_LANGUAGE_TABLE = [
+  { languages: ["python"], extensionPattern: /\.(?:py|pyi)$/ },
+  { languages: ["typescript", "javascript"], extensionPattern: /\.(?:[cm]?[jt]sx?)$/ },
+  { languages: ["java"], extensionPattern: /\.java$/ },
+  { languages: ["kotlin"], extensionPattern: /\.(?:kt|kts)$/ },
+  { languages: ["scala"], extensionPattern: /\.scala$/ },
+  { languages: ["C#"], extensionPattern: /\.cs$/ },
+  { languages: ["Visual Basic"], extensionPattern: /\.vb$/ },
+  { languages: ["CPP"], extensionPattern: /\.(?:cc|cpp|cxx|hpp|hh|hxx)$/ },
+  { languages: ["Rust"], extensionPattern: /\.rs$/ },
+  { languages: ["ruby"], extensionPattern: /\.rb$/ },
+  { languages: ["Dart"], extensionPattern: /\.dart$/ },
+  { languages: ["PHP"], extensionPattern: /\.php$/ }
+];
+function isDocumentLanguage(db, relativePath, entry) {
   const row = db.get(
     `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
     relativePath
   );
-  return row?.language === "Dart" || relativePath.endsWith(".dart");
+  return entry.languages.includes(row?.language ?? "") || entry.extensionPattern.test(relativePath);
 }
-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 isPythonDocument(db, relativePath) {
+  return isDocumentLanguage(db, relativePath, DOCUMENT_LANGUAGE_TABLE[0]);
 }
 function applyLimit(values, limit) {
   return typeof limit === "number" ? values.slice(0, limit) : values;
@@ -2670,9 +2576,6 @@ function scoreDocumentPath(relativePath, rawPattern) {
 function normalizeLookupPath(filePattern) {
   return filePattern.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
 }
-function uniquePatterns(patterns) {
-  return [...new Set(patterns)];
-}
 
 export {
   getSourceImports,
@@ -2680,7 +2583,6 @@ export {
   getSourceText,
   TEST_FILE_PATTERNS,
   TEST_SUPPORT_PATH_PATTERNS,
-  testFileExclusionSql,
   buildFileDepGraph,
   findFirstSymbolMatch,
   findExactSymbolMatch,
@@ -2689,7 +2591,10 @@ export {
   getCalleeRowsForSymbol,
   getCallerRowsForSymbol,
   getSourceReferenceSites,
+  getResolvedReferenceSites,
+  findEnclosingDefinition,
   getDefinitionsForFile,
-  getAllDefinitions
+  getAllDefinitions,
+  getScopedDefinitions
 };
-//# sourceMappingURL=chunk-ALUFWH3U.js.map
+//# sourceMappingURL=chunk-OMCRXXDX.js.map

package/dist/{chunk-Z5VSUOEE.js → chunk-OWJOHUZE.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-ALUFWH3U.js";
+} from "./chunk-OMCRXXDX.js";
 
 // src/queries/deep-chains.ts
 function deepChains(db, opts = {}) {
@@ -41,4 +41,4 @@ function deepChains(db, opts = {}) {
 export {
   deepChains
 };
-//# sourceMappingURL=chunk-Z5VSUOEE.js.map
+//# sourceMappingURL=chunk-OWJOHUZE.js.map

package/dist/{chunk-RJ5GULL6.js → chunk-PEDH3D4G.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-ALUFWH3U.js";
+} from "./chunk-OMCRXXDX.js";
 
 // src/queries/deps.ts
 function deps(db, filePattern) {
@@ -50,4 +50,4 @@ export {
   deps,
   rdeps
 };
-//# sourceMappingURL=chunk-RJ5GULL6.js.map
+//# sourceMappingURL=chunk-PEDH3D4G.js.map

package/dist/{chunk-6UZU7DFL.js → chunk-POAN4SCR.js}

@@ -2,10 +2,10 @@ import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol,
   getCallerRowsForSymbol
-} from "./chunk-ALUFWH3U.js";
+} from "./chunk-OMCRXXDX.js";
 import {
   shortenSymbol
-} from "./chunk-TO3L4YNK.js";
+} from "./chunk-YMSJCSRG.js";
 
 // src/queries/call-graph.ts
 function callGraph(db, symbolPattern) {
@@ -43,4 +43,4 @@ function uniqueRows(rows) {
 export {
   callGraph
 };
-//# sourceMappingURL=chunk-6UZU7DFL.js.map
+//# sourceMappingURL=chunk-POAN4SCR.js.map