@lzehrung/codegraph 2.3.8 → 2.3.10

package/dist/bin/cli.js

@@ -4584,7 +4584,9 @@ __export(languages_exports, {
   languageExtensionPatterns: () => languageExtensionPatterns,
   normalizeLanguageExtensions: () => normalizeLanguageExtensions,
   supportById: () => supportById,
-  supportForFile: () => supportForFile
+  supportForFile: () => supportForFile,
+  supportForFileWithSource: () => supportForFileWithSource,
+  supportForFileWithoutHeaderSample: () => supportForFileWithoutHeaderSample
 });
 import fs5 from "node:fs";
 import path4 from "node:path";
@@ -4628,6 +4630,8 @@ function languageExtensionPatterns(extensions) {
   return Object.keys(normalizeLanguageExtensions(extensions) ?? {}).map(caseInsensitiveExtensionPattern);
 }
 function mappedSupportForFile(filename, extensionMap) {
+  if (!extensionMap)
+    return void 0;
   const mappings = Object.entries(normalizeLanguageExtensions(extensionMap) ?? {}).sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]));
   const lowerFilename = filename.toLowerCase();
   for (const [extension, languageId] of mappings) {
@@ -4637,19 +4641,36 @@ function mappedSupportForFile(filename, extensionMap) {
   }
   return void 0;
 }
-function supportForFile(filename, extensionMap) {
-  const mapped = extensionMap ? mappedSupportForFile(filename, extensionMap) : void 0;
+function supportForFileWithoutHeaderSample(filename, extensionMap) {
+  const mapped = mappedSupportForFile(filename, extensionMap);
   if (mapped)
     return mapped;
   const ext = path4.extname(filename).toLowerCase();
-  if (ext === ".h") {
-    const sample = readFileSample(filename);
-    if (sample && isLikelyCppHeader(sample))
-      return CPP_SUPPORT;
-    return C_SUPPORT;
-  }
   return LANGUAGE_SUPPORTS.find((s) => s.matchExts.includes(ext));
 }
+function supportForFile(filename, extensionMap) {
+  if (path4.extname(filename).toLowerCase() !== ".h") {
+    return supportForFileWithoutHeaderSample(filename, extensionMap);
+  }
+  const mapped = mappedSupportForFile(filename, extensionMap);
+  if (mapped)
+    return mapped;
+  const sample = readFileSample(filename);
+  if (sample && isLikelyCppHeader(sample))
+    return CPP_SUPPORT;
+  return C_SUPPORT;
+}
+function supportForFileWithSource(filename, source, extensionMap) {
+  if (path4.extname(filename).toLowerCase() !== ".h") {
+    return supportForFileWithoutHeaderSample(filename, extensionMap);
+  }
+  const mapped = mappedSupportForFile(filename, extensionMap);
+  if (mapped)
+    return mapped;
+  if (isLikelyCppHeader(source.slice(0, HEADER_SAMPLE_SIZE)))
+    return CPP_SUPPORT;
+  return C_SUPPORT;
+}
 function supportById(id) {
   return LANGUAGE_SUPPORTS.find((s) => s.id === id);
 }
@@ -14546,31 +14567,36 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
       filterIgnoreGlobs: userIgnoreGlobs,
       resolvedSafeSymlinkDirectories: safeSymlinkDirectories
     });
-    const rootSafeFiles = await filterRealPathsWithinRootEntries([...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles], realRoot, reportSourcePathChecks);
+    const candidatePaths = [...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles];
     const seen = /* @__PURE__ */ new Set();
-    return rootSafeFiles.map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath })).filter(({ filePath, realPath }) => {
+    const indexableCandidates = [];
+    for (const candidatePath of candidatePaths) {
+      const filePath = normalizePath(candidatePath);
       if (seen.has(filePath))
-        return false;
+        continue;
       seen.add(filePath);
       const rootRelative = normalizePath(path9.relative(root, filePath));
       if (!isRelativePathInside(rootRelative))
-        return false;
+        continue;
       if (!patternMatchers.some((matcher) => matcher(rootRelative)))
-        return false;
-      const matchesInclude = !includeMatchers.length || includeMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher));
-      if (!matchesInclude)
-        return false;
-      if (userIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher))) {
-        return false;
-      }
-      const ignoredByDefault = defaultIgnoreMatchers.some((matcher) => matcher(rootRelative));
-      if (ignoredByDefault && !(includeMatchers.length > 0 && matchesInclude)) {
-        return false;
+        continue;
+      if (includeMatchers.length && !includeMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher))) {
+        continue;
       }
+      if (userIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher)))
+        continue;
+      if (!includeMatchers.length && defaultIgnoreMatchers.some((matcher) => matcher(rootRelative)))
+        continue;
       if (isIgnoredByGitignore(filePath, gitignoreIndex))
-        return false;
-      return normalizePath(realPath) === filePath || !isIgnoredByGitignore(realPath, gitignoreIndex);
-    }).map(({ filePath }) => filePath);
+        continue;
+      indexableCandidates.push(filePath);
+    }
+    const rootSafeFiles = await filterRealPathsWithinRootEntries(indexableCandidates, realRoot, reportSourcePathChecks);
+    return rootSafeFiles.filter(({ path: filePath, realPath }) => (
+      // The real path only differs when the entry was reached through a symlink, so
+      // testing it again for every ordinary file doubled the matcher work for nothing.
+      normalizePath(realPath) === filePath || !isIgnoredByGitignore(realPath, gitignoreIndex)
+    )).map(({ path: filePath }) => filePath);
   } catch (error51) {
     logWithLevel(options?.logLevel, "debug", `listProjectFiles failed for ${root}: ${stringifyUnknown(error51)}`);
     throw new Error(`Failed to list files in ${root}: ${stringifyUnknown(error51)}`);
@@ -14789,10 +14815,10 @@ async function discoverProjectFilesInternal(projectRoot, options) {
         onlyFiles: false,
         resolvedSafeSymlinkDirectories: safeSymlinkDirectories
       });
-      const rootSafeCandidateEntries = await filterRealPathsWithinRootEntries(gitCandidates.files, realRoot, reportMetadataFileChecks);
-      const filteredFiles = filterGitIgnoredEntries(rootSafeCandidateEntries);
-      const fileMatches = filteredFiles.filter((file2) => PROJECT_FILE_DEFINITIONS.some((definition, definitionIndex) => definition.kind === "file" && matchesDefinition(path9.basename(file2), definitionIndex)));
-      const rawCandidateDirectories = collectCandidateAncestorDirectories(root, rootSafeCandidateEntries.map(({ path: filePath }) => filePath));
+      const candidateFiles = Array.from(new Set(gitCandidates.files.map(normalizePath)));
+      const metadataCandidates = candidateFiles.filter((file2) => PROJECT_FILE_DEFINITIONS.some((definition, definitionIndex) => definition.kind === "file" && matchesDefinition(path9.basename(file2), definitionIndex)));
+      const fileMatches = filterGitIgnoredEntries(await filterRealPathsWithinRootEntries(metadataCandidates, realRoot, reportMetadataFileChecks));
+      const rawCandidateDirectories = collectCandidateAncestorDirectories(root, candidateFiles);
       const candidateDirectoryKeys = new Set(rawCandidateDirectories.map(fileIdentityKey));
       const safeSymlinkDirectoryKeys = new Set(safeSymlinkDirectories.map(fileIdentityKey));
       const directoryMatches = [
@@ -19547,7 +19573,7 @@ async function prepareSourceInput(file2, opts) {
     const rawSource2 = opts?.source ?? await fsp14.readFile(file2, "utf8");
     return prepareSFCSourceInput(rawSource2, framework);
   }
-  const sup = supportForFile(file2, opts?.languageExtensions);
+  const sup = opts?.support ?? supportForFile(file2, opts?.languageExtensions);
   if (!sup)
     throw new UnsupportedParserInputError(file2);
   const rawSource = opts?.source ?? await fsp14.readFile(file2, "utf8");
@@ -21827,6 +21853,243 @@ function extractJsTsDynamicSpecifiers(source, fromFile, projectRoot) {
   }
   return out;
 }
+function maskPythonString(source, mask, start) {
+  const quote = source[start];
+  const triple = source[start + 1] === quote && source[start + 2] === quote;
+  const delimiterLength = triple ? 3 : 1;
+  for (let offset = 0; offset < delimiterLength; offset += 1) {
+    mask[start + offset] = 1;
+  }
+  let index = start + delimiterLength;
+  while (index < source.length) {
+    const ch = source[index];
+    if (!triple && (ch === "\n" || ch === "\r"))
+      return index;
+    mask[index] = 1;
+    if (ch === "\\") {
+      const nextIndex = index + 1;
+      if (nextIndex < source.length)
+        mask[nextIndex] = 1;
+      index += 2;
+      continue;
+    }
+    if (ch === quote) {
+      if (!triple)
+        return index + 1;
+      if (source[index + 1] === quote && source[index + 2] === quote) {
+        mask[index + 1] = 1;
+        mask[index + 2] = 1;
+        return index + delimiterLength;
+      }
+    }
+    index += 1;
+  }
+  return source.length;
+}
+function buildPythonNonCodeMask(source) {
+  if (!source.includes("#") && !source.includes("'") && !source.includes('"'))
+    return void 0;
+  const mask = new Uint8Array(source.length);
+  for (let index = 0; index < source.length; index += 1) {
+    const ch = source[index];
+    if (ch === "#") {
+      while (index < source.length && source[index] !== "\n" && source[index] !== "\r") {
+        mask[index] = 1;
+        index += 1;
+      }
+      index -= 1;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      index = maskPythonString(source, mask, index) - 1;
+    }
+  }
+  return mask;
+}
+function decodePythonStringContent(content, prefix) {
+  if (prefix.includes("r"))
+    return content;
+  let decoded = "";
+  for (let index = 0; index < content.length; index += 1) {
+    const ch = content[index];
+    if (ch !== "\\") {
+      decoded += ch;
+      continue;
+    }
+    index += 1;
+    const escape2 = content[index];
+    if (escape2 === void 0)
+      return null;
+    const simpleEscape = PYTHON_SIMPLE_STRING_ESCAPES[escape2];
+    if (simpleEscape !== void 0) {
+      decoded += simpleEscape;
+      continue;
+    }
+    if (escape2 === "\n")
+      continue;
+    if (escape2 === "\r") {
+      if (content[index + 1] === "\n")
+        index += 1;
+      continue;
+    }
+    let hexLength = 0;
+    if (escape2 === "x")
+      hexLength = 2;
+    else if (escape2 === "u")
+      hexLength = 4;
+    else if (escape2 === "U")
+      hexLength = 8;
+    if (hexLength) {
+      const digits = content.slice(index + 1, index + 1 + hexLength);
+      if (digits.length !== hexLength || !/^[0-9a-fA-F]+$/.test(digits))
+        return null;
+      const codePoint = Number.parseInt(digits, 16);
+      if (codePoint > 1114111)
+        return null;
+      decoded += String.fromCodePoint(codePoint);
+      index += hexLength;
+      continue;
+    }
+    if (escape2 >= "0" && escape2 <= "7") {
+      let end = index + 1;
+      while (end < content.length && end - index < 3) {
+        const digit = content[end];
+        if (digit < "0" || digit > "7")
+          break;
+        end += 1;
+      }
+      decoded += String.fromCodePoint(Number.parseInt(content.slice(index, end), 8));
+      index = end - 1;
+      continue;
+    }
+    decoded += `\\${escape2}`;
+  }
+  return decoded;
+}
+function parsePythonStaticStringLiteral(source, start) {
+  let quoteIndex = start;
+  let prefixLength = 0;
+  while (prefixLength < 2) {
+    const prefixCharacter = source[quoteIndex];
+    if (!prefixCharacter || !"rRuUfF".includes(prefixCharacter))
+      break;
+    quoteIndex += 1;
+    prefixLength += 1;
+  }
+  const prefix = source.slice(start, quoteIndex).toLowerCase();
+  if (!["", "r", "u", "f", "fr", "rf"].includes(prefix))
+    return null;
+  const quote = source[quoteIndex];
+  if (quote !== "'" && quote !== '"')
+    return null;
+  const triple = source[quoteIndex + 1] === quote && source[quoteIndex + 2] === quote;
+  const delimiterLength = triple ? 3 : 1;
+  const contentStart = quoteIndex + delimiterLength;
+  for (let index = contentStart; index < source.length; index += 1) {
+    const ch = source[index];
+    if (!triple && (ch === "\n" || ch === "\r"))
+      return null;
+    if (ch === "\\") {
+      index += 1;
+      continue;
+    }
+    if (ch !== quote)
+      continue;
+    if (triple && (source[index + 1] !== quote || source[index + 2] !== quote))
+      continue;
+    const value = decodePythonStringContent(source.slice(contentStart, index), prefix);
+    if (value === null)
+      return null;
+    return { value, end: index + delimiterLength };
+  }
+  return null;
+}
+function skipPythonExpressionTrivia(source, start) {
+  let index = start;
+  while (index < source.length) {
+    while (index < source.length && /\s/.test(source[index]))
+      index += 1;
+    if (source[index] !== "#")
+      break;
+    while (index < source.length && source[index] !== "\n" && source[index] !== "\r")
+      index += 1;
+  }
+  return index;
+}
+function parsePythonStaticStringExpression(source, start) {
+  let index = skipPythonExpressionTrivia(source, start);
+  let value = "";
+  let literalCount = 0;
+  while (true) {
+    const literal2 = parsePythonStaticStringLiteral(source, index);
+    if (!literal2)
+      break;
+    value += literal2.value;
+    literalCount += 1;
+    index = skipPythonExpressionTrivia(source, literal2.end);
+  }
+  if (!literalCount || source[index] !== "," && source[index] !== ")")
+    return null;
+  return value;
+}
+function collectPythonDynamicImportAliases(source) {
+  const importlibAliases = /* @__PURE__ */ new Set(["importlib"]);
+  const importModuleAliases = /* @__PURE__ */ new Set();
+  const cleaned = stripPythonCommentsAndStrings(source);
+  for (const match of cleaned.matchAll(/^\s*import\s+([^\r\n;]+)/gmu)) {
+    for (const rawClause of (match[1] ?? "").split(",")) {
+      const clause = rawClause.trim();
+      const parsed = PYTHON_IMPORTLIB_ALIAS_PATTERN.exec(clause);
+      if (parsed)
+        importlibAliases.add(parsed[1] ?? "importlib");
+    }
+  }
+  for (const match of cleaned.matchAll(PYTHON_FROM_IMPORTLIB_PATTERN)) {
+    const importList = match[1] ?? match[2] ?? "";
+    for (const rawClause of importList.split(",")) {
+      const clause = rawClause.trim();
+      const parsed = PYTHON_IMPORT_MODULE_ALIAS_PATTERN.exec(clause);
+      if (parsed)
+        importModuleAliases.add(parsed[1] ?? "import_module");
+    }
+  }
+  return { importlibAliases, importModuleAliases };
+}
+function extractPythonDynamicSpecifiers(source) {
+  const out = [];
+  try {
+    const mask = buildPythonNonCodeMask(source);
+    const { importlibAliases, importModuleAliases } = collectPythonDynamicImportAliases(source);
+    const seen = /* @__PURE__ */ new Set();
+    for (const match of source.matchAll(PYTHON_DYNAMIC_CALL_PREFIX_PATTERN)) {
+      if (!matchStartsInCode(mask, match))
+        continue;
+      const receiver = match[1] ?? "";
+      const member = match[2];
+      const isBuiltinImport = !member && receiver === "__import__";
+      const isImportlibCall = member === "import_module" && importlibAliases.has(receiver);
+      const isImportedFunctionCall = !member && importModuleAliases.has(receiver);
+      if (!isBuiltinImport && !isImportlibCall && !isImportedFunctionCall)
+        continue;
+      const argumentStart = (match.index ?? 0) + (match[0]?.length ?? 0);
+      const spec = parsePythonStaticStringExpression(source, argumentStart);
+      if (!spec || !PYTHON_DYNAMIC_MODULE_PATTERN.test(spec) || seen.has(spec))
+        continue;
+      if (isBuiltinImport && spec.startsWith("."))
+        continue;
+      seen.add(spec);
+      out.push({ spec, resolved: "heuristic", confidence: 0.7 });
+    }
+  } catch {
+  }
+  return out;
+}
+function extractDynamicImportSpecifiers(languageId, source, fromFile, projectRoot) {
+  const extractor = DYNAMIC_IMPORT_SPECIFIER_EXTRACTORS[languageId];
+  if (!extractor)
+    return [];
+  return extractor(source, fromFile, projectRoot);
+}
 function extractPythonSpecifiers(source) {
   const out = [];
   try {
@@ -21841,7 +22104,7 @@ function extractPythonSpecifiers(source) {
   }
   return out;
 }
-var PYTHON_DOTTED_NAME_SOURCE;
+var PYTHON_DOTTED_NAME_SOURCE, PYTHON_IMPORTLIB_ALIAS_PATTERN, PYTHON_IMPORT_MODULE_ALIAS_PATTERN, PYTHON_DYNAMIC_CALL_PREFIX_PATTERN, PYTHON_DYNAMIC_MODULE_PATTERN, PYTHON_FROM_IMPORTLIB_PATTERN, PYTHON_SIMPLE_STRING_ESCAPES, DYNAMIC_IMPORT_SPECIFIER_EXTRACTORS;
 var init_specifiers = __esm({
   "dist/util/specifiers.js"() {
     "use strict";
@@ -21849,6 +22112,28 @@ var init_specifiers = __esm({
     init_identifiers();
     init_paths();
     PYTHON_DOTTED_NAME_SOURCE = String.raw`${PYTHON_IDENTIFIER_SOURCE}(?:\.${PYTHON_IDENTIFIER_SOURCE})*`;
+    PYTHON_IMPORTLIB_ALIAS_PATTERN = new RegExp(String.raw`^importlib(?:\s+as\s+(${PYTHON_IDENTIFIER_SOURCE}))?$`, "u");
+    PYTHON_IMPORT_MODULE_ALIAS_PATTERN = new RegExp(String.raw`^import_module(?:\s+as\s+(${PYTHON_IDENTIFIER_SOURCE}))?$`, "u");
+    PYTHON_DYNAMIC_CALL_PREFIX_PATTERN = new RegExp(String.raw`(?<![._\p{XID_Continue}])(${PYTHON_IDENTIFIER_SOURCE})(?:\s*\.\s*(${PYTHON_IDENTIFIER_SOURCE}))?\s*\(\s*(?:name\s*=\s*)?`, "gmu");
+    PYTHON_DYNAMIC_MODULE_PATTERN = new RegExp(String.raw`^\.*${PYTHON_DOTTED_NAME_SOURCE}$`, "u");
+    PYTHON_FROM_IMPORTLIB_PATTERN = /^\s*from\s+importlib\s+import\s+(?:\(([\s\S]*?)\)|([^\r\n;]+))/gmu;
+    PYTHON_SIMPLE_STRING_ESCAPES = {
+      "\\": "\\",
+      "'": "'",
+      '"': '"',
+      a: "\x07",
+      b: "\b",
+      f: "\f",
+      n: "\n",
+      r: "\r",
+      t: "	",
+      v: "\v"
+    };
+    DYNAMIC_IMPORT_SPECIFIER_EXTRACTORS = {
+      js: extractJsTsDynamicSpecifiers,
+      ts: extractJsTsDynamicSpecifiers,
+      python: extractPythonDynamicSpecifiers
+    };
   }
 });
 
@@ -25267,7 +25552,7 @@ var init_extractFacts = __esm({
 import crypto2 from "node:crypto";
 import fsp16 from "node:fs/promises";
 function isSqlFile(filePath, languageExtensions) {
-  return supportForFile(filePath, languageExtensions)?.id === "sql";
+  return supportForFileWithoutHeaderSample(filePath, languageExtensions)?.id === "sql";
 }
 function sqlCorpusSignature(sqlFiles2, fileSignatures) {
   if (!sqlFiles2.length || !fileSignatures)
@@ -25466,6 +25751,17 @@ var init_sourceGraph = __esm({
 });
 
 // dist/graph-edge-collector.js
+function appendMissingSpecifiers(target, incoming) {
+  if (!incoming.length)
+    return;
+  const existing = new Set(target.map((entry) => entry.spec));
+  for (const entry of incoming) {
+    if (existing.has(entry.spec))
+      continue;
+    existing.add(entry.spec);
+    target.push(entry);
+  }
+}
 function deduplicateEdges(edges, rawIsIdentity = false) {
   const deduplicated = /* @__PURE__ */ new Map();
   for (const edge of edges) {
@@ -25505,7 +25801,7 @@ async function collectEdgesForFile(file2, projectRoot, workspaceConfig, opts) {
   const sigEntry = opts.fileSignature;
   const sig = sigEntry?.sig;
   const gitSig = sigEntry?.gitSig;
-  const sqlFile = supportForFile(normalizedFile, opts.languageExtensions)?.id === "sql";
+  const sqlFile = supportForFileWithoutHeaderSample(normalizedFile, opts.languageExtensions)?.id === "sql";
   const emitCacheEntry = (edges2) => {
     if (!sig || !opts.onFileEdges)
       return;
@@ -25572,17 +25868,8 @@ async function collectEdgesForFile(file2, projectRoot, workspaceConfig, opts) {
     ...opts.native ? { native: opts.native } : {},
     ...opts.logLevel ? { logLevel: opts.logLevel } : {}
   });
-  if ((sup.id === "ts" || sup.id === "js") && opts.dynamicImportHeuristics) {
-    const dynamicSpecs = extractJsTsDynamicSpecifiers(src, normalizedFile, projectRoot);
-    if (dynamicSpecs.length) {
-      const existing = new Set(specs.map((entry) => entry.spec));
-      for (const entry of dynamicSpecs) {
-        if (existing.has(entry.spec))
-          continue;
-        existing.add(entry.spec);
-        specs.push(entry);
-      }
-    }
+  if (opts.dynamicImportHeuristics) {
+    appendMissingSpecifiers(specs, extractDynamicImportSpecifiers(sup.id, src, normalizedFile, projectRoot));
   }
   const specSources = specs.map((entry) => ({ entry, support: sup }));
   for (const block of embeddedBlocks) {
@@ -25594,6 +25881,9 @@ async function collectEdgesForFile(file2, projectRoot, workspaceConfig, opts) {
       ...opts.native ? { native: opts.native } : {},
       ...opts.logLevel ? { logLevel: opts.logLevel } : {}
     });
+    if (opts.dynamicImportHeuristics) {
+      appendMissingSpecifiers(blockSpecs, extractDynamicImportSpecifiers(block.sup.id, block.source, normalizedFile, projectRoot));
+    }
     for (const entry of blockSpecs) {
       specSources.push({ entry, support: block.sup });
     }
@@ -25672,7 +25962,7 @@ function canReuseSqlEdgeCache(file2, sqlCorpusSig, fileSignatures, cachedFileEdg
 async function collectGraph(projectRoot, files, opts) {
   const normalizedFiles = files.map(normalizePath);
   const normalizedAllFiles = (opts?.allFiles ?? files).map(normalizePath);
-  const isSqlFile4 = (file2) => supportForFile(file2, opts?.languageExtensions)?.id === "sql";
+  const isSqlFile4 = (file2) => supportForFileWithoutHeaderSample(file2, opts?.languageExtensions)?.id === "sql";
   const hasExplicitReplace = !!opts?.replaceFiles;
   const requestedReplaceSet = hasExplicitReplace ? new Set(Array.from(opts.replaceFiles ?? [], (file2) => normalizePath(file2))) : new Set(normalizedFiles);
   const sqlFiles2 = Array.from(new Set(normalizedAllFiles.filter(isSqlFile4))).sort((left, right) => left.localeCompare(right));
@@ -26336,8 +26626,12 @@ function parsePreparedFileContext(context) {
   }
   throw new Error(`Failed to reconstruct syntax tree for ${context.file}`);
 }
-async function prepareFileForIndexing(file2, native, languageExtensions, source) {
-  const prep = await prepareSourceInput(file2, { languageExtensions, ...source !== void 0 ? { source } : {} });
+async function prepareFileForIndexing(file2, native, languageExtensions, source, support) {
+  const prep = await prepareSourceInput(file2, {
+    languageExtensions,
+    ...source !== void 0 ? { source } : {},
+    ...support ? { support } : {}
+  });
   if (isGraphOnlyLanguage(prep.sup.id)) {
     return {
       file: file2,
@@ -32499,7 +32793,7 @@ async function cacheSignatureForFile(file2, sigInfo, opts) {
 async function buildBloomFilterForFile(file2, opts) {
   try {
     const source = await fsp18.readFile(file2, "utf8");
-    const support = supportForFile(file2, opts?.languageExtensions);
+    const support = supportForFileWithoutHeaderSample(file2, opts?.languageExtensions);
     if (!support)
       return null;
     return buildBloomFilterFromSource(source, support);
@@ -33267,8 +33561,13 @@ function winnowShingles(shingles, windowSize, maxFingerprints) {
   }
   return fingerprints;
 }
-function languageForFile(filePath) {
-  const support = supportForFile(filePath);
+function isDuplicateCandidateFile(filePath) {
+  if (supportForFileWithoutHeaderSample(filePath))
+    return true;
+  return !!textLanguageByExtension[path39.extname(filePath).toLowerCase()];
+}
+function languageForFile(filePath, source) {
+  const support = supportForFileWithSource(filePath, source);
   if (support) {
     return { id: support.id, textOnly: false };
   }
@@ -33443,7 +33742,7 @@ async function getDuplicateAstContext(index, file2, source, cache) {
     return context;
   }
   try {
-    const prepared = await prepareSourceInput(file2, { source });
+    const prepared = await prepareSourceInput(file2, { source, support: supportForFileWithSource(file2, source) });
     const attempt = attemptParsePreparedFileContext({
       file: file2,
       source: prepared.source,
@@ -33610,11 +33909,11 @@ async function collectDuplicateUnits(index, options) {
   return { units, belowThresholdUnits, belowThresholdUnitsByFile };
 }
 async function buildDuplicateUnitsForFile(index, file2, projectRoot, minTokens, maxTokens, shingleSize, windowSize, astContextCache) {
-  const moduleIndex = index.byFile.get(fileIdentityKey(file2));
-  const language = languageForFile(file2);
-  if (!language)
+  const fileKey = fileIdentityKey(file2);
+  const moduleIndex = index.byFile.get(fileKey);
+  if (!isDuplicateCandidateFile(file2))
     return [];
-  let source = index.parsed?.get(fileIdentityKey(file2))?.source;
+  let source = index.parsed?.get(fileKey)?.source;
   if (source === void 0) {
     try {
       source = await fsp19.readFile(file2, "utf8");
@@ -33622,6 +33921,9 @@ async function buildDuplicateUnitsForFile(index, file2, projectRoot, minTokens,
       return [];
     }
   }
+  const language = languageForFile(file2, source);
+  if (!language)
+    return [];
   const astContext = language.textOnly ? void 0 : await getDuplicateAstContext(index, file2, source, astContextCache);
   const { chunks, symbolChunks } = makeDuplicateChunksWithSymbols(file2, language.id, language.textOnly, source, minTokens, maxTokens);
   const symbolUnits = (moduleIndex?.locals ?? []).map((symbol2) => {
@@ -51174,7 +51476,7 @@ function moduleNameLookup(index, file2) {
   if (!lookups) {
     lookups = /* @__PURE__ */ new Map();
     for (const moduleEntry of index.byFile.values()) {
-      const normalizeIdentifier = supportForFile(moduleEntry.file, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
+      const normalizeIdentifier = supportForFileWithoutHeaderSample(moduleEntry.file, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
       const localExports = /* @__PURE__ */ new Map();
       const namespaceReexports = /* @__PURE__ */ new Map();
       const reexports = /* @__PURE__ */ new Map();
@@ -51219,7 +51521,7 @@ function sameSymbolDef(index, left, right) {
   if (fileIdentityKey(left.file) !== fileIdentityKey(right.file) || left.kind !== right.kind) {
     return false;
   }
-  const normalizeIdentifier = supportForFile(left.file, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
+  const normalizeIdentifier = supportForFileWithoutHeaderSample(left.file, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
   if (normalizeIdentifier(left.localName) !== normalizeIdentifier(right.localName)) {
     return false;
   }
@@ -51249,64 +51551,68 @@ function packageNameCacheFor(index) {
   }
   return caches;
 }
+function packageDeclarationSource(index, filePath, fileKey) {
+  const retained = index.parsed?.get(fileKey)?.source;
+  if (retained !== void 0)
+    return retained;
+  try {
+    return fs20.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
 function readGoPackageName(index, filePath) {
   const cache = packageNameCacheFor(index).go;
   const key = fileIdentityKey(filePath);
   const cached2 = cache.get(key);
   if (cached2 !== void 0)
     return cached2;
-  try {
-    const source = fs20.readFileSync(filePath, "utf8");
-    const match = GO_PACKAGE_PATTERN.exec(source);
-    const packageName = match?.[1] ?? null;
-    cache.set(key, packageName);
-    return packageName;
-  } catch {
+  const source = packageDeclarationSource(index, filePath, key);
+  if (source === null) {
     cache.set(key, null);
     return null;
   }
+  const packageName = GO_PACKAGE_PATTERN.exec(source)?.[1] ?? null;
+  cache.set(key, packageName);
+  return packageName;
 }
 function resolveGoPackageExport(index, file2, exportedName) {
-  try {
-    const support = supportForFile(file2, index.languageExtensions);
-    if (!support || support.id !== "go")
-      return null;
-    const directory = packageDirectoryLookup(index, "go").get(fileIdentityKey(path42.dirname(file2)));
-    if (!directory)
-      return null;
-    const sourcePackage = readGoPackageName(index, file2);
-    const candidates = sourcePackage ? directory.byName.get(sourcePackage) ?? [] : directory.all;
-    const matches = [];
-    for (const moduleEntry of candidates) {
-      const names = moduleNameLookup(index, moduleEntry.file);
-      if (!names)
-        continue;
-      for (const target of names.localExports.get(names.normalizeIdentifier(exportedName)) ?? []) {
-        if (!matches.some((candidate) => sameSymbolDef(index, candidate, target))) {
-          matches.push(target);
-        }
+  if (supportForFileWithoutHeaderSample(file2, index.languageExtensions)?.id !== "go")
+    return null;
+  const directory = packageDirectoryLookup(index, "go").get(fileIdentityKey(path42.dirname(file2)));
+  if (!directory)
+    return null;
+  const sourcePackage = readGoPackageName(index, file2);
+  const candidates = sourcePackage ? directory.byName.get(sourcePackage) ?? [] : directory.all;
+  const matches = [];
+  for (const moduleEntry of candidates) {
+    const names = moduleNameLookup(index, moduleEntry.file);
+    if (!names)
+      continue;
+    for (const target of names.localExports.get(names.normalizeIdentifier(exportedName)) ?? []) {
+      if (!matches.some((candidate) => sameSymbolDef(index, candidate, target))) {
+        matches.push(target);
       }
     }
-    return matches.length === 1 ? matches[0] ?? null : null;
-  } catch {
   }
-  return null;
+  return matches.length === 1 ? matches[0] ?? null : null;
 }
 function readPackageNameForLanguage(index, filePath, languageId) {
   const cache = packageNameCacheFor(index).jvm;
-  const key = `${languageId}::${fileIdentityKey(filePath)}`;
+  const fileKey = fileIdentityKey(filePath);
+  const key = `${languageId}::${fileKey}`;
   const cached2 = cache.get(key);
   if (cached2 !== void 0)
     return cached2;
-  try {
-    const source = fs20.readFileSync(filePath, "utf8");
-    const packageName = languageId === "kotlin" ? KOTLIN_PACKAGE_NAME_PATTERN.exec(source)?.[1] ?? null : JAVA_PACKAGE_NAME_PATTERN.exec(source)?.[1] ?? null;
-    cache.set(key, packageName);
-    return packageName;
-  } catch {
+  const source = packageDeclarationSource(index, filePath, fileKey);
+  if (source === null) {
     cache.set(key, null);
     return null;
   }
+  const pattern = languageId === "kotlin" ? KOTLIN_PACKAGE_NAME_PATTERN : JAVA_PACKAGE_NAME_PATTERN;
+  const packageName = pattern.exec(source)?.[1] ?? null;
+  cache.set(key, packageName);
+  return packageName;
 }
 function packageDirectoryLookup(index, languageId) {
   let byLanguage = packageDirectoryLookups.get(index);
@@ -51326,6 +51632,9 @@ function packageDirectoryLookup(index, languageId) {
       directories.set(directoryKey, directory);
     }
     directory.all.push(moduleEntry);
+    const moduleLanguageId = supportForFileWithoutHeaderSample(moduleEntry.file, index.languageExtensions)?.id;
+    if (!moduleLanguageId || !PACKAGE_DECLARING_LANGUAGE_IDS[languageId].has(moduleLanguageId))
+      continue;
     const packageName = languageId === "go" ? readGoPackageName(index, moduleEntry.file) : readPackageNameForLanguage(index, moduleEntry.file, languageId);
     if (!packageName)
       continue;
@@ -51552,30 +51861,23 @@ function resolveImported(index, imp, exportedName) {
     return hit.def;
   if (hit?.kind === "namespace")
     return { namespace: hit.file };
-  try {
-    const support = supportForFile(targetFile);
-    if (support?.id === "java" || support?.id === "kotlin") {
-      const siblingHit = resolveSiblingPackageExport(index, targetFile, exportedName, support.id);
-      if (siblingHit?.kind === "resolved")
-        return siblingHit.def;
-      if (siblingHit?.kind === "namespace") {
-        return { namespace: siblingHit.file };
-      }
+  const support = supportForFileWithoutHeaderSample(targetFile, index.languageExtensions);
+  if (support?.id === "java" || support?.id === "kotlin") {
+    const siblingHit = resolveSiblingPackageExport(index, targetFile, exportedName, support.id);
+    if (siblingHit?.kind === "resolved")
+      return siblingHit.def;
+    if (siblingHit?.kind === "namespace") {
+      return { namespace: siblingHit.file };
     }
-  } catch {
   }
-  try {
-    const support = supportForFile(targetFile);
-    if (support?.id === "python") {
-      const submodule = resolvePythonSubmodule(targetFile, exportedName);
-      if (submodule)
-        return { namespace: submodule };
-    }
-  } catch {
+  if (support?.id === "python") {
+    const submodule = resolvePythonSubmodule(targetFile, exportedName);
+    if (submodule)
+      return { namespace: submodule };
   }
   return null;
 }
-var GO_PACKAGE_PATTERN, JAVA_PACKAGE_NAME_PATTERN, KOTLIN_PACKAGE_NAME_PATTERN, moduleNameLookups, packageDirectoryLookups, packageNameCaches;
+var GO_PACKAGE_PATTERN, JAVA_PACKAGE_NAME_PATTERN, KOTLIN_PACKAGE_NAME_PATTERN, PACKAGE_DECLARING_LANGUAGE_IDS, moduleNameLookups, packageDirectoryLookups, packageNameCaches;
 var init_navigation_resolve = __esm({
   "dist/indexer/navigation-resolve.js"() {
     "use strict";
@@ -51586,6 +51888,11 @@ var init_navigation_resolve = __esm({
     GO_PACKAGE_PATTERN = new RegExp(String.raw`^\s*package\s+(${GO_IDENTIFIER_SOURCE})`, "mu");
     JAVA_PACKAGE_NAME_PATTERN = new RegExp(String.raw`^\s*package\s+(${JAVA_IDENTIFIER_SOURCE}(?:\.${JAVA_IDENTIFIER_SOURCE})*)\s*;`, "mu");
     KOTLIN_PACKAGE_NAME_PATTERN = new RegExp(String.raw`^\s*package\s+(${KOTLIN_IDENTIFIER_SOURCE}(?:\.${KOTLIN_IDENTIFIER_SOURCE})*)`, "mu");
+    PACKAGE_DECLARING_LANGUAGE_IDS = {
+      go: /* @__PURE__ */ new Set(["go"]),
+      java: /* @__PURE__ */ new Set(["java", "kotlin"]),
+      kotlin: /* @__PURE__ */ new Set(["java", "kotlin"])
+    };
     moduleNameLookups = /* @__PURE__ */ new WeakMap();
     packageDirectoryLookups = /* @__PURE__ */ new WeakMap();
     packageNameCaches = /* @__PURE__ */ new WeakMap();
@@ -54643,7 +54950,7 @@ function isNativeWorkerEligibleFile(filePath, support) {
 function countNativeWorkerEligibleFiles(files, languageExtensions) {
   let count = 0;
   for (const file2 of files) {
-    if (isNativeWorkerEligibleFile(file2, supportForFile(file2, languageExtensions)))
+    if (isNativeWorkerEligibleFile(file2, supportForFileWithoutHeaderSample(file2, languageExtensions)))
       count++;
   }
   return count;
@@ -54778,10 +55085,10 @@ async function prepareFileContextForBuild(file2, support, opts, workerSetup, rep
           workerSetup.report.errors.push({ file: file2, message: stringifyUnknown(error51) });
         }
       }
-      prepared = await prepareFileForIndexing(file2, opts?.native, opts?.languageExtensions, source);
+      prepared = await prepareFileForIndexing(file2, opts?.native, opts?.languageExtensions, source, support);
     }
   } else {
-    prepared = await prepareFileForIndexing(file2, opts?.native, opts?.languageExtensions, source);
+    prepared = await prepareFileForIndexing(file2, opts?.native, opts?.languageExtensions, source, support);
   }
   recordPreparedNativeExecutionOutcome(report, prepared);
   return prepared;
@@ -55425,7 +55732,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   const sqlFiles2 = normalizedFiles.filter((file2) => {
     if (!languageExtensions)
       return path47.extname(file2).toLowerCase() === ".sql";
-    return supportForFile(file2, languageExtensions)?.id === "sql";
+    return supportForFileWithoutHeaderSample(file2, languageExtensions)?.id === "sql";
   }).sort((left, right) => left.localeCompare(right));
   const fileSignatures = await prepareFileSignatures({
     projectRoot,
@@ -55443,7 +55750,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     return sqlFactCachePromise;
   };
   const shouldProvideSqlFactCache = (file2, sigInfo, cachedEdgesEntry) => {
-    if (supportForFile(file2, opts?.languageExtensions)?.id !== "sql")
+    if (supportForFileWithoutHeaderSample(file2, opts?.languageExtensions)?.id !== "sql")
       return false;
     if (!cachedEdgesEntry || !sqlCorpusSig || cachedEdgesEntry.sqlCorpusSig !== sqlCorpusSig)
       return true;
@@ -55726,7 +56033,8 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
       await writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries, projectRoot));
     }
     if (buildStartedAt !== void 0) {
-      emitIndexLifecycleProgress(opts, "complete", "build", index.byFile.size, performance5.now() - buildStartedAt);
+      const progressStartedAt = opts?.progressStartedAt ?? buildStartedAt;
+      emitIndexLifecycleProgress(opts, "complete", "build", index.byFile.size, performance5.now() - progressStartedAt);
     }
     return index;
   } finally {
@@ -55801,9 +56109,13 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
   }
 }
 async function buildProjectIndex(projectRoot, opts) {
-  return buildProjectIndexWithManifestOptions(projectRoot, opts);
+  return buildProjectIndexWithManifestOptions(projectRoot, {
+    ...opts,
+    progressStartedAt: opts?.progressStartedAt ?? performance5.now()
+  });
 }
-async function buildProjectIndexFromFiles(projectRoot, inputFiles, opts) {
+async function buildProjectIndexFromFiles(projectRoot, inputFiles, rawOpts) {
+  const opts = { ...rawOpts, progressStartedAt: rawOpts?.progressStartedAt ?? performance5.now() };
   try {
     const useDiskCache = (opts?.cache ?? "off") === "disk";
     const normalizedInputFiles = await normalizeIndexedFileInputsWithinRoot(projectRoot, inputFiles, "Index file");
@@ -55832,7 +56144,11 @@ async function buildDeclaredScopeIndex(projectRoot, scopeFiles, opts) {
     }
   }
 }
-async function buildProjectIndexIncremental(projectRoot, opts) {
+async function buildProjectIndexIncremental(projectRoot, rawOpts) {
+  const opts = {
+    ...rawOpts,
+    progressStartedAt: rawOpts?.progressStartedAt ?? performance5.now()
+  };
   await initializeFileIdentityCaseSensitivity(projectRoot);
   clearResolutionCaches();
   const graphOptions = normalizeGraphOptions(opts?.graph);
@@ -58037,7 +58353,24 @@ function emitAgentFilePlanProgress(options) {
     total: 0
   });
 }
+function agentDiscoveryProgressReporter(options) {
+  const onProgress = options.buildOptions?.onProgress;
+  if (!onProgress)
+    return void 0;
+  return ({ activity, current, total }) => {
+    onProgress({
+      type: "progress",
+      phase: "update",
+      mode: "check",
+      message: activity,
+      activity,
+      current,
+      total
+    });
+  };
+}
 async function resolveAgentSessionFilePlan(options) {
+  const startedAt = performance.now();
   const { discoveryOptions, graphOptions, languageExtensions, cacheLocation } = await resolveAgentDiscoverySettings(options);
   const incrementalOptions = {
     ...options.buildOptions,
@@ -58051,6 +58384,7 @@ async function resolveAgentSessionFilePlan(options) {
     return {
       files: incrementalPlan.files,
       incrementalPlan,
+      startedAt,
       ...discoveryOptions ? { discoveryOptions } : {},
       ...graphOptions ? { graphOptions } : {},
       ...languageExtensions ? { languageExtensions } : {},
@@ -58061,9 +58395,14 @@ async function resolveAgentSessionFilePlan(options) {
   const customPatterns = languageExtensionPatterns(languageExtensions);
   const patterns = customPatterns.length ? [...DEFAULT_PROJECT_PATTERNS2, ...customPatterns] : void 0;
   emitAgentFilePlanProgress(options);
-  const files = await listProjectFiles(options.root, patterns, discoveryOptions);
+  const onDiscoveryProgress = agentDiscoveryProgressReporter(options);
+  const files = await listProjectFiles(options.root, patterns, {
+    ...discoveryOptions,
+    ...onDiscoveryProgress ? { onDiscoveryProgress } : {}
+  });
   return {
     files,
+    startedAt,
     ...discoveryOptions ? { discoveryOptions } : {},
     ...graphOptions ? { graphOptions } : {},
     ...languageExtensions ? { languageExtensions } : {},
@@ -58216,7 +58555,7 @@ function createAgentSession(options) {
     if (cachedBase)
       return cachedBase;
     const loadPromise = (async () => {
-      const { files, discoveryOptions, graphOptions, languageExtensions, cacheLocation, incrementalPlan } = await loadFilePlan();
+      const { files, discoveryOptions, graphOptions, languageExtensions, cacheLocation, incrementalPlan, startedAt } = await loadFilePlan();
       const buildOptions = {
         ...options.buildOptions,
         ...graphOptions ? { graph: graphOptions } : {},
@@ -58224,6 +58563,8 @@ function createAgentSession(options) {
         keepParsed: options.buildOptions?.keepParsed ?? true,
         files,
         filesAreProjectScope: true,
+        // Discovery ran before this build, so the completion event must measure from there.
+        progressStartedAt: options.buildOptions?.progressStartedAt ?? startedAt,
         ...incrementalPlan ? {
           reconciledManifestUpdatedAt: incrementalPlan.manifestUpdatedAt,
           reconciledWorkingTreeDiffFiles: incrementalPlan.workingTreeDiffFiles,
@@ -64194,7 +64535,7 @@ async function checkMarkdownLinksInFiles(projectRoot, files) {
       return absoluteFile;
     }
   }));
-  const markdownFiles = Array.from(new Set(markdownFileCandidates)).filter((file2) => isFilePathWithinRoot(realRoot, file2)).filter((file2) => supportForFile(file2)?.id === "markdown");
+  const markdownFiles = Array.from(new Set(markdownFileCandidates)).filter((file2) => isFilePathWithinRoot(realRoot, file2)).filter((file2) => supportForFileWithoutHeaderSample(file2)?.id === "markdown");
   const targetStatusByPath = /* @__PURE__ */ new Map();
   const anchorsByPath = /* @__PURE__ */ new Map();
   const failures = [];
@@ -64233,7 +64574,7 @@ async function checkMarkdownLinksInFiles(projectRoot, files) {
         failures.push(toFailure(realRoot, displayFile, occurrence, "outside_root", resolvedTarget));
         continue;
       }
-      if (!target.fragment || targetStatus.isDirectory || supportForFile(resolvedTarget)?.id !== "markdown")
+      if (!target.fragment || targetStatus.isDirectory || supportForFileWithoutHeaderSample(resolvedTarget)?.id !== "markdown")
         continue;
       const anchors = await cachedMarkdownAnchors(targetStatus.realPath, anchorsByPath);
       if (!anchors.has(target.fragment)) {
@@ -65302,7 +65643,7 @@ var init_navigation_php = __esm({
 function sameDef(left, right, languageExtensions) {
   const leftIndex = left.range.start.index ?? 0;
   const rightIndex = right.range.start.index ?? 0;
-  const normalizeIdentifier = supportForFile(left.file, languageExtensions)?.normalizeIdentifier ?? ((name) => name);
+  const normalizeIdentifier = supportForFileWithoutHeaderSample(left.file, languageExtensions)?.normalizeIdentifier ?? ((name) => name);
   return fileIdentityKey(left.file) === fileIdentityKey(right.file) && normalizeIdentifier(left.localName) === normalizeIdentifier(right.localName) && leftIndex === rightIndex;
 }
 function rangeContains(range, pos) {
@@ -65585,7 +65926,7 @@ function hasExpandedNamedImport(moduleIndex, targetFile, symbolName) {
   return moduleIndex.imports.some((candidate) => candidate.kind === "named" && candidate.local === symbolName && candidate.imported === symbolName && typeof candidate.resolved === "string" && fileIdentityKey(candidate.resolved) === targetKey);
 }
 function referenceCandidateCacheKey(index, def, exportedNames) {
-  const normalizeIdentifier = supportForFile(def.file, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
+  const normalizeIdentifier = supportForFileWithoutHeaderSample(def.file, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
   const sortedNames = exportedNames.map(normalizeIdentifier).sort();
   return `${fileIdentityKey(def.file)}::${def.range.start.index ?? 0}::canonical::${sortedNames.join("\0")}`;
 }
@@ -66363,7 +66704,7 @@ async function findReferences(index, req, opts) {
       const filter = index.bloomFilters?.get(fileIdentityKey(candidateFile));
       if (!filter)
         return true;
-      const normalizeIdentifier = supportForFile(candidateFile, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
+      const normalizeIdentifier = supportForFileWithoutHeaderSample(candidateFile, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
       const aliases = getCandidateReferenceNames(module2, definitionFile, exportedNameSet);
       if (!aliases.length) {
         return [...exportedNames, ...phpQualifiedNames].some((candidateName) => filter.mightContain(normalizeIdentifier(candidateName)));
@@ -66393,7 +66734,7 @@ async function findReferences(index, req, opts) {
       }
       return scopeIndex;
     };
-    if (supportForFile(fileId, index.languageExtensions)?.supportsExportFromReferences) {
+    if (supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.supportsExportFromReferences) {
       for (const entry of module2.exports) {
         if (hasReachedMaxReferences())
           break;
@@ -66521,7 +66862,7 @@ async function findReferences(index, req, opts) {
       if (hasReachedMaxReferences())
         break;
       const filter = index.bloomFilters?.get(fileIdentityKey(fileId));
-      const canonicalName = supportForFile(fileId, index.languageExtensions)?.normalizeIdentifier(def.localName) ?? def.localName;
+      const canonicalName = supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.normalizeIdentifier(def.localName) ?? def.localName;
       if (filter && !filter.mightContain(canonicalName))
         continue;
       const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
@@ -68023,7 +68364,7 @@ function hasDiagnostics(diagnostics) {
   return !!(diagnostics.missingFiles.length || diagnostics.symbolMappingParseFailures.length || diagnostics.memberResolutionCoverage?.limitedLanguages.length);
 }
 function isRiskRelevantSymbolMappingFile(file2) {
-  return supportForFile(file2)?.supportsCrossModuleSymbols ?? false;
+  return supportForFileWithoutHeaderSample(file2)?.supportsCrossModuleSymbols ?? false;
 }
 var init_risk = __esm({
   "dist/review/risk.js"() {
@@ -69919,7 +70260,7 @@ async function collectVerifiedCallsiteReferences(index, changedSymbol, maxRefs,
     if (!shouldIncludeReference(file2)) {
       continue;
     }
-    const support = supportForFile(file2);
+    const support = supportForFileWithoutHeaderSample(file2, index.languageExtensions);
     if (!support || !supportsCallCompatibilityLanguage(support.id)) {
       continue;
     }
@@ -70332,7 +70673,7 @@ var init_hunks = __esm({
 // dist/impact/map.js
 async function locateChangedSymbolsWithLines(index, file2, hunks) {
   const changedLines = collectChangedLines(hunks);
-  if (isGraphOnlyFile(file2)) {
+  if (isGraphOnlyFile(file2, index.languageExtensions)) {
     return { changedSymbols: [], changedLines, parseFailed: false };
   }
   let parsedEntry;
@@ -70472,7 +70813,7 @@ function sameRangeStartPosition(left, right) {
   return left.start.line === right.start.line && left.start.column === right.start.column && left.start.index === right.start.index;
 }
 async function mapChangedLinesToSymbols(index, file2, hunks, changedLinesOverride) {
-  if (isGraphOnlyFile(file2)) {
+  if (isGraphOnlyFile(file2, index.languageExtensions)) {
     return /* @__PURE__ */ new Map();
   }
   let parsedEntry;
@@ -70513,8 +70854,8 @@ async function mapChangedLinesToSymbols(index, file2, hunks, changedLinesOverrid
   }
   return linesByHandle;
 }
-function isGraphOnlyFile(file2) {
-  const support = supportForFile(file2);
+function isGraphOnlyFile(file2, languageExtensions) {
+  const support = supportForFileWithoutHeaderSample(file2, languageExtensions);
   return support ? isGraphOnlyLanguage(support.id) : false;
 }
 function hasOverlapSorted(sorted, lo, hi) {
@@ -73054,17 +73395,25 @@ function isNodeBuiltinSpecifier(specifier) {
   return NODE_BUILTIN_MODULES2.has(specifier);
 }
 function isGraphOnlyImporter(file2) {
-  const support = supportForFile(file2);
+  const support = supportForFileWithoutHeaderSample(file2);
   return support ? isGraphOnlyLanguage(support.id) : false;
 }
 function getUnresolvedImports(graph, opts = {}) {
   const unresolved = /* @__PURE__ */ new Map();
   const classificationCache = /* @__PURE__ */ new Map();
+  const graphOnlyImporterCache = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
     if (edge.to.type !== "external")
       continue;
-    if (!opts.includeGraphOnly && isGraphOnlyImporter(edge.from))
-      continue;
+    if (!opts.includeGraphOnly) {
+      let graphOnly = graphOnlyImporterCache.get(edge.from);
+      if (graphOnly === void 0) {
+        graphOnly = isGraphOnlyImporter(edge.from);
+        graphOnlyImporterCache.set(edge.from, graphOnly);
+      }
+      if (graphOnly)
+        continue;
+    }
     if (isNodeBuiltinSpecifier(edge.to.name) || isNodeBuiltinSpecifier(edge.raw))
       continue;
     const classificationKey = `${edge.from}\0${edge.to.name}\0${edge.raw}\0${opts.projectRoot ?? ""}`;
@@ -74135,7 +74484,9 @@ function detectQueryIndexSurface(relativePath3) {
   return "code";
 }
 function buildQueryTextChunks(file2, text) {
-  const support = supportForFile(file2);
+  return chunkQueryText(file2, text, supportForFileWithSource(file2, text));
+}
+function chunkQueryText(file2, text, support) {
   const languageId = support ? CHUNK_LANGUAGE_ALIASES[support.id] ?? support.id : void 0;
   const language = languageId ? LANG_CONFIGS[languageId] : void 0;
   if (language) {
@@ -74173,13 +74524,13 @@ function buildQueryTextChunks(file2, text) {
 async function prepareQueryIndexFile(input) {
   try {
     const stat = await fs32.stat(input.absolutePath);
-    const support = supportForFile(input.absolutePath);
     if (stat.size > MAX_QUERY_INDEX_TEXT_BYTES) {
+      const support2 = supportForFile(input.absolutePath);
       return {
         path: input.path,
         sourceIdentity: input.sourceIdentity,
         surface: detectQueryIndexSurface(input.path),
-        ...support ? { language: support.id } : {},
+        ...support2 ? { language: support2.id } : {},
         byteLength: stat.size,
         lineCount: 0,
         normalizedText: compressQueryText(""),
@@ -74188,6 +74539,7 @@ async function prepareQueryIndexFile(input) {
       };
     }
     const text = await fs32.readFile(input.absolutePath, "utf8");
+    const support = supportForFileWithSource(input.absolutePath, text);
     return {
       path: input.path,
       sourceIdentity: input.sourceIdentity,
@@ -74196,7 +74548,7 @@ async function prepareQueryIndexFile(input) {
       byteLength: stat.size,
       lineCount: text ? text.split(/\r?\n/).length : 0,
       normalizedText: compressQueryText(normalizeQuerySearchText(text)),
-      chunks: buildQueryTextChunks(input.absolutePath, text).map((chunk) => ({
+      chunks: chunkQueryText(input.absolutePath, text, support).map((chunk) => ({
         ...chunk,
         text: compressQueryText(chunk.text)
       })),
@@ -82485,15 +82837,16 @@ function validateNewName(snapshot, def, newName) {
   const file2 = normalizeAgentFilePath(snapshot.root, def.file);
   const conflicts = [];
   const invalidPathCharacters = newName.includes("/") || newName.includes("\\") || newName.includes("\0");
-  const support = supportForFile(def.file, snapshot.index.languageExtensions);
+  const support = supportForFileWithoutHeaderSample(def.file, snapshot.index.languageExtensions);
   const allowsDollar = support?.id === "js" || support?.id === "ts" || support?.id === "tsx";
   const identifierPattern = allowsDollar ? /^[$_\p{ID_Start}](?:[$_\p{ID_Continue}]|\u200c|\u200d)*$/u : /^[_\p{ID_Start}][_\p{ID_Continue}]*$/u;
   if (!newName || invalidPathCharacters || !identifierPattern.test(newName)) {
+    const displaySupport = supportForFile(def.file, snapshot.index.languageExtensions);
     conflicts.push({
       file: file2,
       location: { file: file2, range: def.range },
       reason: "invalid_identifier",
-      message: `"${newName}" is not a valid ${support?.id ?? "conservative"} identifier.`
+      message: `"${newName}" is not a valid ${displaySupport?.id ?? "conservative"} identifier.`
     });
   }
   if (newName !== def.localName && newName.toLocaleLowerCase() === def.localName.toLocaleLowerCase()) {