@lzehrung/codegraph 2.2.1 → 2.2.2

package/dist/bin/cli.js

@@ -2091,6 +2091,7 @@ var init_typescript = __esm({
       extensions: [".ts", ".mts", ".cts"],
       structure: BASE_STRUCTURE,
       graph: BASE_GRAPH,
+      supportsExportFromReferences: true,
       ...BASE_HELPERS,
       isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
       native: {
@@ -2112,6 +2113,7 @@ var init_typescript = __esm({
         ]
       },
       graph: BASE_GRAPH,
+      supportsExportFromReferences: true,
       ...BASE_HELPERS,
       isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
       native: {
@@ -2148,6 +2150,7 @@ var init_javascript = __esm({
     JAVASCRIPT_DEF = {
       id: "js",
       extensions: [".js", ".jsx", ".mjs", ".cjs"],
+      supportsExportFromReferences: true,
       structure: {
         blocks: [...ECMASCRIPT_CORE_FUNCTION_BLOCKS, ...ECMASCRIPT_MODULE_VAR_BLOCKS],
         splitPoints: [...ECMASCRIPT_CONTROL_SPLIT_POINTS],
@@ -4489,6 +4492,7 @@ function adaptDefinition(def) {
     membersAreImplicitlyInScope: def.membersAreImplicitlyInScope ?? true,
     supportsCrossModuleSymbols: def.supportsCrossModuleSymbols || false,
     isTypeOnly: def.isTypeOnly || (() => false),
+    supportsExportFromReferences: def.supportsExportFromReferences ?? false,
     usesQueryDrivenLocals: def.usesQueryDrivenLocals || false,
     normalizeIdentifier: def.normalizeIdentifier || ((name) => name),
     ...def.native ? { native: def.native } : {}
@@ -18361,8 +18365,7 @@ async function resolveSpecifier(fromFile, spec, projectRoot, matchPath, workspac
     }
     const fromExt = path20.extname(fromFile).toLowerCase();
     const prefersPathLikeFallback = [".go", ".java", ".cs", ".rb", ".rs", ".swift"].includes(fromExt);
-    const shouldTryPathLikeFallback = prefersPathLikeFallback || spec.includes("/") || spec.includes(".");
-    if (shouldTryPathLikeFallback) {
+    if (prefersPathLikeFallback) {
       const pathLike = await resolvePathLikeModule(projectRoot, spec, opts?.resolutionExtensions);
       if (pathLike && isFilePathWithinRoot(projectRoot, pathLike)) {
         setResolveSpecifierCacheEntry(cacheKey3, pathLike);
@@ -26712,8 +26715,11 @@ async function collectImportsForFile(file2, projectRoot, opts) {
     });
     return imports;
   }
-  const tsCfg = resolvedSup.id === "ts" || resolvedSup.id === "tsx" ? await loadNearestTsconfigFor(file2, projectRoot, opts?.logLevel) : void 0;
-  const workspaceConfig = await loadWorkspaceConfig(projectRoot);
+  let matchPath = opts?.matchPath;
+  if ((resolvedSup.id === "ts" || resolvedSup.id === "tsx") && !matchPath) {
+    ({ matchPath } = await loadNearestTsconfigFor(file2, projectRoot, opts?.logLevel));
+  }
+  const workspaceConfig = opts?.workspaceConfig ?? await loadWorkspaceConfig(projectRoot);
   const resolvedImportCache = /* @__PURE__ */ new Map();
   const resolveFrom = async (from, phpImportType) => {
     const cacheKey3 = `${from}\0${phpImportType ?? ""}`;
@@ -26723,7 +26729,7 @@ async function collectImportsForFile(file2, projectRoot, opts) {
     const resolutionHints = opts?.graphOptions?.resolutionHints;
     const resolved = (async () => {
       const result = await resolveImportSpecifier(projectRoot, file2, from, resolvedSup.id, {
-        ...tsCfg?.matchPath ? { matchPath: tsCfg.matchPath } : {},
+        ...matchPath ? { matchPath } : {},
         ...workspaceConfig ? { workspaceConfig } : {},
         resolveNodeModules: !!opts?.graphOptions?.resolveNodeModules,
         ...resolutionHints ? { resolutionHints } : {},
@@ -27653,9 +27659,11 @@ function collectLocalsAndExportsFromSource(file2, source, support, imports = [],
       }
     }
   }
-  const methodSupplementTree = ensureTree();
-  if (methodSupplementTree) {
-    supplementMethodLocalsFromSyntaxTree(methodSupplementTree.rootNode);
+  if (support.id === "ts" || support.id === "tsx" || support.id === "js") {
+    const methodSupplementTree = ensureTree();
+    if (methodSupplementTree) {
+      supplementMethodLocalsFromSyntaxTree(methodSupplementTree.rootNode);
+    }
   }
   function supplementMethodLocalsFromSyntaxTree(node) {
     if (METHOD_LIKE_BINDING_NODE_TYPES.has(node.type)) {
@@ -28036,7 +28044,8 @@ function collectLocalsAndExportsFromSource(file2, source, support, imports = [],
         throw error51;
     }
   }
-  if (support.id === "ts" || support.id === "tsx" || support.id === "js") {
+  const isJsLike = support.id === "ts" || support.id === "tsx" || support.id === "js";
+  if (isJsLike) {
     appendJsLikeRegexFallbackExports(file2, source, locals, exports);
   }
   if (support.id === "python") {
@@ -29915,19 +29924,9 @@ var init_location = __esm({
 // dist/indexer/build-cache/options.js
 import crypto5 from "node:crypto";
 import path36 from "node:path";
-function functionSource(value) {
-  return typeof value === "function" ? Function.prototype.toString.call(value) : void 0;
-}
 function languageDefinitionFingerprintDescriptor(definition) {
   const native = definition.native;
-  const nativeNormalizeQuery = functionSource(native?.normalizeQuery);
-  const classifyDefinition = functionSource(definition.classifyDefinition);
-  const isDeclarationName = functionSource(definition.isDeclarationName);
-  const scopeDeclarationNames = definition.scopeDeclarationNames === "all" ? "all" : functionSource(definition.scopeDeclarationNames);
-  const normalizeIdentifier = functionSource(definition.normalizeIdentifier);
-  const createsBlockScope = functionSource(definition.createsBlockScope);
-  const createsFunctionScope = functionSource(definition.createsFunctionScope);
-  const isTypeOnly = functionSource(definition.isTypeOnly);
+  const scopeDeclarationNames = definition.scopeDeclarationNames === "all" ? "all" : void 0;
   return {
     id: definition.id,
     extensions: [...definition.extensions].sort(),
@@ -29938,38 +29937,38 @@ function languageDefinitionFingerprintDescriptor(definition) {
     ...native ? {
       native: {
         authoritativeKinds: [...native.authoritativeKinds ?? []].sort(),
-        notes: [...native.notes ?? []],
-        ...nativeNormalizeQuery ? { normalizeQuery: nativeNormalizeQuery } : {}
+        notes: [...native.notes ?? []]
       }
     } : {},
     behavior: {
-      // Booleans serialize under the same defaults adaptDefinition applies, so the
-      // fingerprint tracks effective behavior rather than incidental optionality.
+      // Function-valued behavior fields are covered by LANGUAGE_BEHAVIOR_EPOCH.
+      // Bundlers rewrite their source text, so hashing it would make equivalent
+      // CLI and library builds invalidate one another's caches.
       usesQueryDrivenLocals: definition.usesQueryDrivenLocals ?? false,
       membersAreImplicitlyInScope: definition.membersAreImplicitlyInScope ?? true,
-      ...classifyDefinition ? { classifyDefinition } : {},
-      ...isDeclarationName ? { isDeclarationName } : {},
-      ...scopeDeclarationNames ? { scopeDeclarationNames } : {},
-      ...normalizeIdentifier ? { normalizeIdentifier } : {},
-      ...createsBlockScope ? { createsBlockScope } : {},
-      ...createsFunctionScope ? { createsFunctionScope } : {},
-      ...isTypeOnly ? { isTypeOnly } : {}
+      supportsExportFromReferences: definition.supportsExportFromReferences ?? false,
+      ...scopeDeclarationNames ? { scopeDeclarationNames } : {}
     }
   };
 }
-function getImplementationFingerprint() {
-  if (cachedImplementationFingerprint)
-    return cachedImplementationFingerprint;
+function getImplementationFingerprintForEpoch(languageBehaviorEpoch) {
   const definitions = getAllLanguages().map(languageDefinitionFingerprintDescriptor).sort((left, right) => left.id.localeCompare(right.id));
   const hash2 = crypto5.createHash("sha256");
-  hash2.update("codegraph-implementation-fingerprint-v2");
+  hash2.update("codegraph-implementation-fingerprint-v3");
   hash2.update("\0");
   hash2.update(String(CORE_ALGORITHM_EPOCH));
   hash2.update("\0");
+  hash2.update(String(languageBehaviorEpoch));
+  hash2.update("\0");
   hash2.update(getCodegraphVersion());
   hash2.update("\0");
   hash2.update(JSON.stringify(definitions));
-  cachedImplementationFingerprint = hash2.digest("hex");
+  return hash2.digest("hex");
+}
+function getImplementationFingerprint() {
+  if (cachedImplementationFingerprint)
+    return cachedImplementationFingerprint;
+  cachedImplementationFingerprint = getImplementationFingerprintForEpoch(LANGUAGE_BEHAVIOR_EPOCH);
   return cachedImplementationFingerprint;
 }
 function normalizeManifestBuildOptions(opts) {
@@ -30139,7 +30138,7 @@ function graphOptionsEqual(a, b) {
   }
   return true;
 }
-var CORE_ALGORITHM_EPOCH, cachedImplementationFingerprint;
+var CORE_ALGORITHM_EPOCH, LANGUAGE_BEHAVIOR_EPOCH, cachedImplementationFingerprint;
 var init_options2 = __esm({
   "dist/indexer/build-cache/options.js"() {
     "use strict";
@@ -30151,6 +30150,7 @@ var init_options2 = __esm({
     init_treeSitterNative();
     init_languages();
     CORE_ALGORITHM_EPOCH = 2;
+    LANGUAGE_BEHAVIOR_EPOCH = 1;
   }
 });
 
@@ -49660,53 +49660,52 @@ function transformHandle(root, value, toRelative) {
   return `${transformPath(root, file2, toRelative)}${value.slice(separator)}`;
 }
 function transformModule(root, module2, toRelative) {
-  const copy = structuredClone(module2);
   const file2 = (value) => transformPath(root, value, toRelative);
-  copy.file = file2(copy.file);
-  for (const local of copy.locals)
-    local.file = file2(local.file);
-  for (const entry of copy.exports) {
-    if (entry.type === "local") {
-      entry.target.file = file2(entry.target.file);
-    } else {
-      transformPersistedExportFromModule(root, entry, toRelative);
-    }
-  }
-  for (const binding of copy.imports) {
-    if (typeof binding.resolved === "string")
-      binding.resolved = file2(binding.resolved);
-  }
-  return copy;
+  return {
+    ...module2,
+    file: file2(module2.file),
+    locals: module2.locals.map((local) => ({ ...local, file: file2(local.file) })),
+    exports: module2.exports.map((entry) => {
+      if (entry.type === "local") {
+        return { ...entry, target: { ...entry.target, file: file2(entry.target.file) } };
+      }
+      const copy = { ...entry };
+      transformPersistedExportFromModule(root, copy, toRelative);
+      return copy;
+    }),
+    imports: module2.imports.map((binding) => ({
+      ...binding,
+      ...typeof binding.resolved === "string" ? { resolved: file2(binding.resolved) } : {}
+    }))
+  };
 }
 function transformSnapshotPaths(payload, root, toRelative) {
-  const copy = structuredClone(payload);
-  copy.graph.nodes = copy.graph.nodes.map((node) => transformPath(root, node, toRelative));
-  copy.graph.edges = copy.graph.edges.map((edge) => ({
-    ...edge,
-    from: transformPath(root, edge.from, toRelative),
-    to: edge.to.type === "file" ? { ...edge.to, path: transformPath(root, edge.to.path, toRelative) } : edge.to
-  }));
-  copy.modules = copy.modules.map((module2) => transformModule(root, module2, toRelative));
-  if (copy.projectFiles) {
-    copy.projectFiles = copy.projectFiles.map((file2) => ({
-      ...file2,
-      path: transformPath(root, file2.path, toRelative),
-      projectRoot: transformPath(root, file2.projectRoot, toRelative)
-    }));
-  }
-  if (copy.bloomFilters) {
-    const bloomFilters = {};
-    for (const [file2, filter] of Object.entries(copy.bloomFilters)) {
-      bloomFilters[transformPath(root, file2, toRelative)] = filter;
-    }
-    copy.bloomFilters = bloomFilters;
-  }
-  const fileSignatures = {};
-  for (const [file2, signature] of Object.entries(copy.fileSignatures ?? {})) {
-    fileSignatures[transformPath(root, file2, toRelative)] = signature;
-  }
-  copy.fileSignatures = fileSignatures;
-  return copy;
+  const bloomFilters = payload.bloomFilters ? Object.fromEntries(Object.entries(payload.bloomFilters).map(([file2, filter]) => [transformPath(root, file2, toRelative), filter])) : void 0;
+  const fileSignatures = Object.fromEntries(Object.entries(payload.fileSignatures ?? {}).map(([file2, signature]) => [
+    transformPath(root, file2, toRelative),
+    signature
+  ]));
+  return {
+    ...payload,
+    graph: {
+      nodes: payload.graph.nodes.map((node) => transformPath(root, node, toRelative)),
+      edges: payload.graph.edges.map((edge) => ({
+        ...edge,
+        from: transformPath(root, edge.from, toRelative),
+        to: edge.to.type === "file" ? { ...edge.to, path: transformPath(root, edge.to.path, toRelative) } : edge.to
+      }))
+    },
+    modules: payload.modules.map((module2) => transformModule(root, module2, toRelative)),
+    ...payload.projectFiles ? {
+      projectFiles: payload.projectFiles.map((file2) => ({
+        ...file2,
+        path: transformPath(root, file2.path, toRelative),
+        projectRoot: transformPath(root, file2.projectRoot, toRelative)
+      }))
+    } : {},
+    ...bloomFilters ? { bloomFilters } : {},
+    fileSignatures
+  };
 }
 function migrateProjectSnapshotPayload(value, currentRoot) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -49833,6 +49832,14 @@ function setBoundedSnapshotCache(cache, key, value) {
     cache.delete(oldestKey);
   }
 }
+function freezeSnapshotPayload(value) {
+  if (!value || typeof value !== "object")
+    return value;
+  Object.freeze(value);
+  for (const child of Object.values(value))
+    freezeSnapshotPayload(child);
+  return value;
+}
 function materializeDetailedSymbolGraph(payload) {
   const graph = structuredClone(payload);
   return {
@@ -49853,6 +49860,9 @@ function recordSnapshotCorruption(report, artifact, reason, logLevel) {
   }
   logWithLevel(logLevel, "warn", `Warning: Corrupt cache artifact ${artifact}: ${reason}`);
 }
+function recordSnapshotInvalidation(artifact, reason, logLevel) {
+  logWithLevel(logLevel, "debug", `Cache artifact invalidated ${artifact}: ${reason}`);
+}
 function isMissingArtifactError(error51) {
   return !!error51 && typeof error51 === "object" && "code" in error51 && error51.code === "ENOENT";
 }
@@ -49878,18 +49888,23 @@ function transformCachedProjectSnapshot(snapshotPath, identity, rawPayload, proj
   const cached2 = transformedSnapshotCache.get(snapshotPath);
   if (cached2 && cached2.root === projectRoot && sameSnapshotFileIdentity(cached2.identity, identity)) {
     setBoundedSnapshotCache(transformedSnapshotCache, snapshotPath, cached2);
-    return structuredClone(cached2.payload);
+    return cached2.payload;
   }
   const migratedPayload = migrateProjectSnapshotPayload(rawPayload, projectRoot);
   const payload = migratedPayload && typeof migratedPayload === "object" && !Array.isArray(migratedPayload) ? transformSnapshotPaths(migratedPayload, projectRoot, false) : migratedPayload;
-  setBoundedSnapshotCache(transformedSnapshotCache, snapshotPath, { identity, root: projectRoot, payload });
-  return structuredClone(payload);
+  const immutablePayload = freezeSnapshotPayload(payload);
+  setBoundedSnapshotCache(transformedSnapshotCache, snapshotPath, {
+    identity,
+    root: projectRoot,
+    payload: immutablePayload
+  });
+  return immutablePayload;
 }
 function transformCachedProjectSnapshotModules(snapshotPath, identity, rawPayload, projectRoot) {
   const cached2 = transformedSnapshotModulesCache.get(snapshotPath);
   if (cached2 && cached2.root === projectRoot && sameSnapshotFileIdentity(cached2.identity, identity)) {
     setBoundedSnapshotCache(transformedSnapshotModulesCache, snapshotPath, cached2);
-    return structuredClone(cached2.payload);
+    return cached2.payload;
   }
   const migratedPayload = migrateProjectSnapshotPayload(rawPayload, projectRoot);
   if (!migratedPayload || typeof migratedPayload !== "object" || Array.isArray(migratedPayload)) {
@@ -49899,7 +49914,7 @@ function transformCachedProjectSnapshotModules(snapshotPath, identity, rawPayloa
   if (!Array.isArray(payload.modules) || !payload.fileSignatures || typeof payload.fileSignatures !== "object") {
     return migratedPayload;
   }
-  const modules = structuredClone(payload.modules).map((module2) => transformModule(projectRoot, module2, false));
+  const modules = payload.modules.map((module2) => transformModule(projectRoot, module2, false));
   const fileSignatures = {};
   for (const [file2, signature] of Object.entries(payload.fileSignatures)) {
     fileSignatures[transformPath(projectRoot, file2, false)] = signature;
@@ -49914,12 +49929,13 @@ function transformCachedProjectSnapshotModules(snapshotPath, identity, rawPayloa
     modules,
     fileSignatures
   };
+  const immutablePayload = freezeSnapshotPayload(transformed);
   setBoundedSnapshotCache(transformedSnapshotModulesCache, snapshotPath, {
     identity,
     root: projectRoot,
-    payload: transformed
+    payload: immutablePayload
   });
-  return structuredClone(transformed);
+  return immutablePayload;
 }
 function projectIndexManifestEntries(entries) {
   return new Map(Array.from(entries, ([file2, entry]) => [
@@ -49939,7 +49955,12 @@ async function tryLoadProjectIndexSnapshot(projectRoot, opts, manifestEntries, r
     const payload = transformCachedProjectSnapshot(projectSnapshotPath(projectRoot, opts), parsedSnapshot.identity, parsedSnapshot.payload, projectRoot);
     const nativeRuntimeFingerprint = getNativeRuntimeFingerprint(opts?.native);
     const implementationFingerprint = getImplementationFingerprint();
-    if (!isProjectIndexSnapshotPayload(payload) || payload.filesSignature !== filesSignature || payload.nativeMode !== normalizedSnapshotNativeMode(opts?.native) || payload.nativeRuntimeFingerprint !== nativeRuntimeFingerprint || payload.implementationFingerprint !== implementationFingerprint) {
+    if (!isProjectIndexSnapshotPayload(payload)) {
+      recordSnapshotCorruption(report, projectSnapshotPath(projectRoot, opts), "invalid project snapshot payload", opts?.logLevel);
+      return null;
+    }
+    if (payload.filesSignature !== filesSignature || payload.nativeMode !== normalizedSnapshotNativeMode(opts?.native) || payload.nativeRuntimeFingerprint !== nativeRuntimeFingerprint || payload.implementationFingerprint !== implementationFingerprint) {
+      recordSnapshotInvalidation(projectSnapshotPath(projectRoot, opts), "project snapshot identity mismatch", opts?.logLevel);
       return null;
     }
     const graph = {
@@ -49987,7 +50008,12 @@ async function tryLoadProjectSnapshotModules(projectRoot, opts, fileSignatures,
     const payload = transformCachedProjectSnapshotModules(projectSnapshotPath(projectRoot, opts), parsedSnapshot.identity, parsedSnapshot.payload, projectRoot);
     const nativeRuntimeFingerprint = getNativeRuntimeFingerprint(opts?.native);
     const implementationFingerprint = getImplementationFingerprint();
-    if (!isProjectSnapshotModulesPayload(payload) || payload.nativeMode !== normalizedSnapshotNativeMode(opts?.native) || payload.nativeRuntimeFingerprint !== nativeRuntimeFingerprint || payload.implementationFingerprint !== implementationFingerprint) {
+    if (!isProjectSnapshotModulesPayload(payload)) {
+      recordSnapshotCorruption(report, projectSnapshotPath(projectRoot, opts), "invalid project snapshot payload", opts?.logLevel);
+      return null;
+    }
+    if (payload.nativeMode !== normalizedSnapshotNativeMode(opts?.native) || payload.nativeRuntimeFingerprint !== nativeRuntimeFingerprint || payload.implementationFingerprint !== implementationFingerprint) {
+      recordSnapshotInvalidation(projectSnapshotPath(projectRoot, opts), "project snapshot identity mismatch", opts?.logLevel);
       return null;
     }
     const normalizedFileSignatures = new Map(Object.entries(payload.fileSignatures).map(([file2, signature]) => [fileIdentityKey(file2), signature]));
@@ -50019,7 +50045,13 @@ async function tryLoadPersistedBloomFilters(projectRoot, opts, report) {
     if (sidecarBloom) {
       return createPersistedBloomFilters(sidecarBloom.bloomFilters, sidecarBloom.fileSignatures, projectRoot);
     }
-    recordSnapshotCorruption(report, sidecarPath, "invalid bloom filter payload", opts?.logLevel);
+    const sidecar = sidecarParsed;
+    const identityMismatch = isUnknownRecord(sidecarParsed) && (sidecar.version !== BLOOM_FILTER_SNAPSHOT_VERSION || sidecar.implementationFingerprint !== getImplementationFingerprint() || typeof sidecar.projectSnapshotIdentity !== "string");
+    if (identityMismatch) {
+      recordSnapshotInvalidation(sidecarPath, "bloom filter identity mismatch", opts?.logLevel);
+    } else {
+      recordSnapshotCorruption(report, sidecarPath, "invalid bloom filter payload", opts?.logLevel);
+    }
   } catch (error51) {
     const isMissing = error51 && typeof error51 === "object" && "code" in error51 && error51.code === "ENOENT";
     if (!isMissing) {
@@ -50229,10 +50261,18 @@ async function tryLoadDetailedSymbolGraphSnapshot(projectRoot, opts, index, repo
       ...migratedPayload,
       graph: transformDetailedGraph(migratedPayload.graph, projectRoot, false)
     } : migratedPayload;
-    if (!isDetailedSymbolGraphSnapshotPayload(payload) || payload.implementationFingerprint !== getImplementationFingerprint() || payload.projectSnapshotIdentity !== index.projectSnapshotIdentity) {
+    if (!isDetailedSymbolGraphSnapshotPayload(payload)) {
       recordSnapshotCorruption(report, snapshotPath, "invalid detailed symbol graph payload", opts?.logLevel);
       return null;
     }
+    if (payload.implementationFingerprint !== getImplementationFingerprint()) {
+      recordSnapshotInvalidation(snapshotPath, "implementation fingerprint mismatch", opts?.logLevel);
+      return null;
+    }
+    if (payload.projectSnapshotIdentity !== index.projectSnapshotIdentity) {
+      recordSnapshotInvalidation(snapshotPath, "project snapshot identity mismatch", opts?.logLevel);
+      return null;
+    }
     const graph = materializeDetailedSymbolGraph(payload.graph);
     if (!await isDetailedSymbolGraphCompatibleWithProject(projectRoot, index, graph)) {
       recordSnapshotCorruption(report, snapshotPath, "detailed symbol graph does not match project", opts?.logLevel);
@@ -52374,7 +52414,7 @@ function createNativeWorkerPool(opts) {
   const workerPath = resolveNativeWorkerPath();
   return new Piscina({
     filename: workerPath,
-    minThreads: threads,
+    minThreads: 1,
     maxThreads: threads,
     maxQueue: opts?.maxQueue ?? threads * 4,
     idleTimeout: 3e4,
@@ -52803,16 +52843,13 @@ function isConfinedFileReadError(error51) {
 function createEmptyModuleIndex(file2) {
   return { file: file2, exports: [], imports: [], locals: [] };
 }
-async function resolveCrossModuleSymbolExports(file2, mod2, support, projectRoot, graphOptions, workspaceConfig, logLevel) {
-  if (!support.supportsCrossModuleSymbols)
+async function resolveCrossModuleSymbolExports(file2, mod2, support, projectRoot, graphOptions, workspaceConfig, matchPath) {
+  if (!support.supportsCrossModuleSymbols || !isJsTsLanguage(support.id))
     return;
-  if (!isJsTsLanguage(support.id))
+  const reexports = mod2.exports.filter((entry) => entry.type === "reexport" || entry.type === "exportStar" || entry.type === "namespaceReexport");
+  if (!reexports.length)
     return;
-  const { matchPath } = await Promise.resolve().then(() => (init_resolution(), resolution_exports)).then((mod3) => mod3.loadNearestTsconfigFor(file2, projectRoot, logLevel));
-  for (const entry of mod2.exports) {
-    if (entry.type !== "reexport" && entry.type !== "exportStar" && entry.type !== "namespaceReexport") {
-      continue;
-    }
+  for (const entry of reexports) {
     if (entry.fromModule.startsWith(".")) {
       entry.moduleSpecifier ??= entry.fromModule;
       const resolved = await resolveSpecifier(file2, entry.fromModule, projectRoot, matchPath, workspaceConfig, {
@@ -52876,6 +52913,8 @@ async function buildIndexedModuleForFile(args) {
   }
   const sharedImportOptions = {
     graphOptions: args.graphOptions,
+    ...args.workspaceConfig ? { workspaceConfig: args.workspaceConfig } : {},
+    ...args.matchPath ? { matchPath: args.matchPath } : {},
     ...args.opts?.native ? { native: args.opts.native } : {},
     ...args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {},
     ...args.opts?.languageExtensions ? { languageExtensions: args.opts.languageExtensions } : {},
@@ -52909,7 +52948,7 @@ async function buildIndexedModuleForFile(args) {
     });
   }
   mod2.imports = imports;
-  await resolveCrossModuleSymbolExports(args.file, mod2, sup, args.projectRoot, args.graphOptions, args.workspaceConfig, args.opts?.logLevel);
+  await resolveCrossModuleSymbolExports(args.file, mod2, sup, args.projectRoot, args.graphOptions, args.workspaceConfig, args.matchPath);
   const sigInfo = args.fileSignatures.get(args.file);
   const cacheable = !prepared.nativeFallbackReason && !lacksParserContext;
   let cacheWrite;
@@ -53093,7 +53132,7 @@ async function prepareFileSignatures(args) {
       args.trustedSources?.set(file2, source);
       return [file2, fileSignatureFromSource(source, gitSig)];
     }
-    const sigInfo = await fileSignature(file2, args.needsContentHash ? args.opts?.cacheStrict : false, gitSig, {
+    const sigInfo = await fileSignature(file2, args.signatureStrict, gitSig, {
       forceContentHash: args.cacheEnabled && !gitSig
     });
     return [file2, sigInfo];
@@ -53106,7 +53145,7 @@ async function buildProjectIndexFromExport(projectRoot, opts, helperOpts) {
 async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperOpts) {
   clearResolutionCaches();
   await initializeFileIdentityCaseSensitivity(projectRoot);
-  const { normalizedProjectRoot, report, timings, totalStart, cacheMode, cacheEnabled, graphOptions, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts);
+  const { normalizedProjectRoot, report, timings, totalStart, cacheEnabled, graphOptions, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts);
   const manifestMode = helperOpts?.manifestMode ?? "off";
   const useManifest = manifestMode !== "off";
   const shouldWriteManifest = manifestMode === "read-write";
@@ -53165,11 +53204,13 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   const manifestEntriesForIndex = useManifest ? projectIndexManifestEntries2(cachedGraphEntries ?? []) : /* @__PURE__ */ new Map();
   const modules = /* @__PURE__ */ new Map();
   const gitAvailable = await isGitRepo(projectRoot);
-  const useGitSignatures = gitAvailable && (cacheMode !== "off" || opts?.cacheStrict);
+  const needsPersistentSignatures = cacheEnabled || useManifest;
+  const useGitSignatures = gitAvailable && needsPersistentSignatures;
   const gitSigMap = useGitSignatures ? await getGitBlobHashes(projectRoot, normalizedFiles, {
     gitAvailable,
     ...opts?.logLevel ? { logLevel: opts.logLevel } : {}
   }) : /* @__PURE__ */ new Map();
+  const signatureStrict = needsPersistentSignatures ? opts?.cacheStrict : false;
   const conc = edgeProbeConcurrency;
   const languageExtensions = normalizeLanguageExtensions(opts?.languageExtensions);
   const sqlFiles2 = normalizedFiles.filter((file2) => {
@@ -53180,10 +53221,9 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   const fileSignatures = await prepareFileSignatures({
     projectRoot,
     files: sqlFiles2,
-    opts,
     gitSigMap,
     cacheEnabled,
-    needsContentHash: true,
+    signatureStrict,
     concurrency: conc,
     ...confinedRoot ? { confinedRoot, trustedSources } : {}
   });
@@ -53212,7 +53252,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
           trustedSources?.set(file2, source);
           sigInfo = fileSignatureFromSource(source, gitSig);
         } else {
-          sigInfo = await fileSignature(file2, opts?.cacheStrict, gitSig, {
+          sigInfo = await fileSignature(file2, signatureStrict, gitSig, {
             forceContentHash: cacheEnabled && !gitSig
           });
         }
@@ -53240,6 +53280,16 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const persistedBloomFilters = bloomFilterCache ? await tryLoadPersistedBloomFilters(projectRoot, opts, report) : null;
     const parsedMap = /* @__PURE__ */ new Map();
     const workspaceConfig = await loadWorkspaceConfig(projectRoot);
+    const tsconfigMatchPathByDirectory = /* @__PURE__ */ new Map();
+    const loadMatchPathForFile = (file2) => {
+      const directory = path47.dirname(file2);
+      let matchPath = tsconfigMatchPathByDirectory.get(directory);
+      if (!matchPath) {
+        matchPath = loadNearestTsconfigFor(file2, projectRoot, opts?.logLevel).then((tsconfig) => tsconfig.matchPath);
+        tsconfigMatchPathByDirectory.set(directory, matchPath);
+      }
+      return matchPath;
+    };
     const parseStart = performance5.now();
     const graph = { nodes: new Set(normalizedFiles), edges: [] };
     const onFileEdges = manifestEntries ? (file2, entry) => {
@@ -53312,6 +53362,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
         ensureBuildProgressStarted();
         let graphContext;
         let cacheWrite;
+        const matchPath = support.id === "ts" || support.id === "tsx" ? await loadMatchPathForFile(file2) : void 0;
         if (!mod2) {
           const built = await buildIndexedModuleForFile({
             file: file2,
@@ -53320,7 +53371,8 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
             opts,
             report,
             graphOptions,
-            workspaceConfig,
+            ...workspaceConfig ? { workspaceConfig } : {},
+            ...matchPath ? { matchPath } : {},
             workerSetup,
             ...resolverEnvironmentFingerprint !== void 0 ? { resolverEnvironmentFingerprint } : {},
             parsedMap,
@@ -53852,6 +53904,16 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
       }
     }
     const workspaceConfig = await loadWorkspaceConfig(projectRoot);
+    const tsconfigMatchPathByDirectory = /* @__PURE__ */ new Map();
+    const loadMatchPathForFile = (file2) => {
+      const directory = path47.dirname(file2);
+      let matchPath = tsconfigMatchPathByDirectory.get(directory);
+      if (!matchPath) {
+        matchPath = loadNearestTsconfigFor(file2, projectRoot, opts?.logLevel).then((tsconfig) => tsconfig.matchPath);
+        tsconfigMatchPathByDirectory.set(directory, matchPath);
+      }
+      return matchPath;
+    };
     const conc = buildConcurrency(opts);
     let workerSetup = emptyWorkerPoolSetup();
     try {
@@ -53863,10 +53925,9 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
       const fileSignatures = await prepareFileSignatures({
         projectRoot,
         files: Array.from(allFiles),
-        opts,
         gitSigMap,
         cacheEnabled,
-        needsContentHash: cacheEnabled || manifestUsed || opts?.cacheStrict === true,
+        signatureStrict: opts?.cacheStrict,
         concurrency: conc
       });
       const modules = /* @__PURE__ */ new Map();
@@ -53965,6 +54026,7 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
             const support = supportForFile(file2, opts?.languageExtensions);
             if (!support)
               return [file2, createEmptyModuleIndex(file2)];
+            const matchPath = support.id === "ts" || support.id === "tsx" ? await loadMatchPathForFile(file2) : void 0;
             const built = await buildIndexedModuleForFile({
               file: file2,
               support,
@@ -53972,7 +54034,8 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
               opts,
               report,
               graphOptions,
-              workspaceConfig,
+              ...workspaceConfig ? { workspaceConfig } : {},
+              ...matchPath ? { matchPath } : {},
               workerSetup,
               parsedMap,
               parsedCacheMaxEntries: parsedCacheMaxEntries(opts),
@@ -62959,7 +63022,7 @@ var init_reference_context = __esm({
 
 // dist/indexer/navigation-references.js
 function exportFromIdentifier(index, fileId, range, parsed) {
-  if (!isJsTsLanguage(parsed.sup.id))
+  if (!parsed.sup.supportsExportFromReferences)
     return null;
   const startIndex = range.start.index;
   if (typeof startIndex !== "number")
@@ -63083,8 +63146,16 @@ async function collectVerifiedNamedNodeReferences(index, fileId, symbolName, exp
     if (maxVerified !== void 0 && maxVerified > 0 && verified.length >= maxVerified) {
       break;
     }
-    if (exportFromIdentifier(index, fileId, range, parsed)?.isExportFrom)
-      continue;
+    const exportFrom = exportFromIdentifier(index, fileId, range, parsed);
+    if (exportFrom?.entry) {
+      const reexported = resolveExport(index, exportFrom.entry.fromModule, exportFrom.entry.sourceSpecifier);
+      if (reexported?.kind === "resolved") {
+        if (sameDef(reexported.def, expectedDef, index.languageExtensions)) {
+          verified.push({ range, via: { reexport: true } });
+        }
+        continue;
+      }
+    }
     const resolved = await resolveDefinition({
       file: fileId,
       line: range.start.line,
@@ -63093,7 +63164,11 @@ async function collectVerifiedNamedNodeReferences(index, fileId, symbolName, exp
     if (resolved.status !== "ok" || !resolved.definition)
       continue;
     if (sameDef(resolved.definition, expectedDef, index.languageExtensions)) {
-      verified.push({ range, ...resolved.provenance ? { provenance: resolved.provenance } : {} });
+      verified.push({
+        range,
+        ...exportFrom?.isExportFrom ? { via: { reexport: true } } : {},
+        ...resolved.provenance ? { provenance: resolved.provenance } : {}
+      });
     }
   }
   return verified;
@@ -63188,6 +63263,9 @@ function filesExportingDefinition(index, def, exportedNames) {
         break;
       }
     }
+    if (moduleIndex.exports.some((entry) => entry.type === "reexport" && exportedNames.includes(entry.sourceSpecifier) && resolveExport(index, entry.fromModule, entry.sourceSpecifier)?.kind !== "resolved")) {
+      files.set(fileIdentityKey(fileId), fileId);
+    }
   }
   return [...files.values()];
 }
@@ -63227,7 +63305,13 @@ function getCachedReferenceCandidateFiles(index, def, exportedNames, hasGlobalNa
     return cached2;
   const candidates = /* @__PURE__ */ new Map();
   const candidateFileEntries = getIndexedReferenceCandidateFiles(index, def, exportedNames) ?? Array.from(index.byFile.values(), (module2) => module2.file);
-  const exportingFiles = new Set(filesExportingDefinition(index, def, exportedNames).map((file2) => fileIdentityKey(file2)));
+  const exportingFileIds = filesExportingDefinition(index, def, exportedNames);
+  const exportingFiles = new Set(exportingFileIds.map((file2) => fileIdentityKey(file2)));
+  for (const fileId of exportingFileIds) {
+    if (fileIdentityKey(fileId) !== fileIdentityKey(def.file)) {
+      candidates.set(fileIdentityKey(fileId), fileId);
+    }
+  }
   for (const fileId of candidateFileEntries) {
     if (fileIdentityKey(fileId) === fileIdentityKey(def.file))
       continue;
@@ -63251,7 +63335,6 @@ var init_navigation_references = __esm({
   "dist/indexer/navigation-references.js"() {
     "use strict";
     init_languages();
-    init_js_family();
     init_paths();
     init_ast();
     init_parse_context();
@@ -63713,6 +63796,30 @@ async function goToDefinition(index, req, parsedContext) {
       name = sliceText(declNameNode, source);
     }
   }
+  if (node && sup.supportsExportFromReferences && index.projectRoot) {
+    const exportFrom = exportFromIdentifier(index, file2, toRange(node), context);
+    if (exportFrom?.entry) {
+      let resolvedTarget;
+      if (index.byFile.has(fileIdentityKey(exportFrom.entry.fromModule))) {
+        resolvedTarget = exportFrom.entry.fromModule;
+      } else {
+        const { matchPath } = await loadNearestTsconfigFor(file2, index.projectRoot);
+        resolvedTarget = await resolveImportSpecifier(index.projectRoot, file2, exportFrom.entry.moduleSpecifier ?? exportFrom.entry.fromModule, sup.id, {
+          ...matchPath ? { matchPath } : {}
+        });
+      }
+      if (typeof resolvedTarget === "string") {
+        const hit = resolveExport(index, resolvedTarget, exportFrom.entry.sourceSpecifier);
+        if (hit?.kind === "resolved") {
+          return okGoToResult(index, hit.def, {
+            via: { importedFrom: resolvedTarget, exportedName: exportFrom.entry.sourceSpecifier },
+            resolution: "import",
+            confidence: "high"
+          });
+        }
+      }
+    }
+  }
   if (sup.supportsCrossModuleSymbols) {
     const scopeIndex = node.parent && isMemberAccessNode(sup, node.parent) ? getOrBuildScopeIndex(index, file2, source, sup, mod2, tree) : null;
     const memberAccessResult = await resolveMemberAccessDefinition({
@@ -63903,6 +64010,28 @@ async function findReferences(index, req, opts) {
       }
       return scopeIndex;
     };
+    if (supportForFile(fileId, index.languageExtensions)?.supportsExportFromReferences) {
+      for (const entry of module2.exports) {
+        if (hasReachedMaxReferences())
+          break;
+        if (entry.type !== "reexport")
+          continue;
+        if (!exportedNameSet.has(entry.sourceSpecifier))
+          continue;
+        const resolved = resolveExport(index, entry.fromModule, entry.sourceSpecifier);
+        if (resolved?.kind === "resolved" && !sameDef(resolved.def, def, index.languageExtensions))
+          continue;
+        const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
+        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, entry.sourceSpecifier, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
+        for (const { range, provenance: provenance3, via } of ranges) {
+          if (hasReachedMaxReferences())
+            break;
+          if (!via?.reexport)
+            continue;
+          pushRef({ file: fileId, range, via, ...provenance3 ? { provenance: provenance3 } : {} });
+        }
+      }
+    }
     for (const imp of module2.imports) {
       if (hasReachedMaxReferences())
         break;
@@ -63938,10 +64067,15 @@ async function findReferences(index, req, opts) {
           }
           const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
           const ranges = await collectVerifiedNamedNodeReferences(index, fileId, exportedName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
-          for (const { range, provenance: provenance3 } of ranges) {
+          for (const { range, provenance: provenance3, via } of ranges) {
             if (hasReachedMaxReferences())
               break;
-            pushRef({ file: fileId, range, via: { import: imp }, ...provenance3 ? { provenance: provenance3 } : {} });
+            pushRef({
+              file: fileId,
+              range,
+              via: { import: imp, ...via ?? {} },
+              ...provenance3 ? { provenance: provenance3 } : {}
+            });
           }
         } else {
           let exported = exportedName;
@@ -63957,10 +64091,15 @@ async function findReferences(index, req, opts) {
           if (fileIdentityKey(targetFile) !== fileIdentityKey(definitionFile)) {
             const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
             const ranges = await collectVerifiedNamedNodeReferences(index, fileId, imp.local, def, (params, parsed2) => goToDefinition(index, params, parsed2), remainingReferences);
-            for (const { range, provenance: provenance3 } of ranges) {
+            for (const { range, provenance: provenance3, via } of ranges) {
               if (hasReachedMaxReferences())
                 break;
-              pushRef({ file: fileId, range, via: { import: imp }, ...provenance3 ? { provenance: provenance3 } : {} });
+              pushRef({
+                file: fileId,
+                range,
+                via: { import: imp, ...via ?? {} },
+                ...provenance3 ? { provenance: provenance3 } : {}
+              });
             }
             continue;
           }
@@ -63986,10 +64125,10 @@ async function findReferences(index, req, opts) {
         if (hasReachedMaxReferences())
           break;
         const ranges = await collectVerifiedNamedNodeReferences(index, fileId, candidateName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
-        for (const { range, provenance: provenance3 } of ranges) {
+        for (const { range, provenance: provenance3, via } of ranges) {
           if (hasReachedMaxReferences())
             break;
-          pushRef({ file: fileId, range, ...provenance3 ? { provenance: provenance3 } : {} });
+          pushRef({ file: fileId, range, ...via ? { via } : {}, ...provenance3 ? { provenance: provenance3 } : {} });
         }
       }
     }
@@ -64004,10 +64143,10 @@ async function findReferences(index, req, opts) {
         continue;
       const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
       const ranges = await collectVerifiedNamedNodeReferences(index, fileId, def.localName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
-      for (const { range, provenance: provenance3 } of ranges) {
+      for (const { range, provenance: provenance3, via } of ranges) {
         if (hasReachedMaxReferences())
           break;
-        pushRef({ file: fileId, range, ...provenance3 ? { provenance: provenance3 } : {} });
+        pushRef({ file: fileId, range, ...via ? { via } : {}, ...provenance3 ? { provenance: provenance3 } : {} });
       }
     }
   }