@mrclrchtr/supi-lsp 11.1.0 → 11.3.0

package/src/config/typescript-launch.ts

@@ -0,0 +1,276 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { major, prerelease, valid } from "semver";
+import type { ServerConfig, TypeScriptSelection } from "./server-config.ts";
+
+interface CompilerPackage {
+  directory: string;
+  name?: string;
+  version?: string;
+  bin?: unknown;
+}
+
+/** Launch options and truthful compiler facts for one root; never cached across starts. */
+export interface TypeScriptLaunch {
+  /** Native packages use their declared Node launcher, without a PATH dependency. */
+  command?: string;
+  args?: string[];
+  initializationOptions: unknown;
+  typescript?: TypeScriptSelection;
+}
+
+/** Retain already-known selection facts when validating launch files fails. */
+class TypeScriptLaunchError extends Error {
+  readonly typescript: TypeScriptSelection | undefined;
+  constructor(message: string, options: ErrorOptions & { typescript?: TypeScriptSelection }) {
+    super(message, options);
+    this.typescript = options.typescript;
+  }
+}
+
+/** True for an installed package name/alias, never a path, URL, or package subpath. */
+export function isTypeScriptPackageName(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    /^(?:@[a-z0-9._-]+\/)?[a-z0-9_][a-z0-9._-]*$/i.test(value) &&
+    ![".", ".."].includes(value)
+  );
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+/** Resolve fresh package files using Node's root-relative node_modules search paths.
+ * Probing the package directory (rather than require.resolve's cached realpath) both
+ * detects broken selections and observes package-manager symlink changes on retry.
+ * Package exports need not expose package.json; no compiler code is executed.
+ */
+function findPackage(name: string, from: string): CompilerPackage | undefined {
+  const require = createRequire(path.join(from, "__supi_lsp_resolve__.cjs"));
+  for (const base of require.resolve.paths(name) ?? []) {
+    const directory = path.join(base, name);
+    try {
+      fs.lstatSync(directory);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+      throw error;
+    }
+    return readCompilerPackage(fs.realpathSync(directory));
+  }
+  return undefined;
+}
+
+function readCompilerPackage(directory: string): CompilerPackage {
+  const manifest = record(
+    JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8")),
+  );
+  if (
+    !manifest ||
+    (manifest.name !== undefined && typeof manifest.name !== "string") ||
+    (manifest.version !== undefined &&
+      (typeof manifest.version !== "string" || !valid(manifest.version)))
+  ) {
+    throw new Error(`Invalid package manifest at ${directory}`);
+  }
+  return {
+    directory,
+    name: typeof manifest.name === "string" ? manifest.name : undefined,
+    version: typeof manifest.version === "string" ? manifest.version : undefined,
+    bin: manifest.bin,
+  };
+}
+
+/** Apply the bounded TypeScript compiler policy without changing the settings snapshot.
+ * Programmatic configurations without loader provenance remain manual. Explicit
+ * launch fields bypass all package probing; a selector may not coexist with them.
+ */
+export function resolveTypeScriptLaunch(
+  name: string,
+  config: ServerConfig,
+  root: string,
+): TypeScriptLaunch {
+  const unchanged = { initializationOptions: config.initializationOptions };
+  if (name !== "typescript") return unchanged;
+  if (isManualTypeScriptLaunch(config, root)) return unchanged;
+  const selector = config.typescriptPackage;
+  let selected = selector ?? "typescript";
+  try {
+    if (!isTypeScriptPackageName(selected))
+      throw new Error("Expected an installed package name or alias, not a filesystem path.");
+    const probe = (installedName: string) => {
+      selected = installedName; // Retain the failing candidate's identity for the error.
+      return findPackage(installedName, root);
+    };
+    const selection =
+      selector === undefined ? selectAutomaticCompiler(probe) : { selected, pkg: probe(selected) };
+    const { pkg } = selection;
+    selected = selection.selected;
+    if (!pkg) {
+      if (selector !== undefined) throw new Error("Selected package is not installed.");
+      return unchanged; // Preserve TLS's legacy lookup when neither candidate exists.
+    }
+    return compilerLaunch(config.initializationOptions, pkg, selected);
+  } catch (error) {
+    throw new TypeScriptLaunchError(
+      `TypeScript launch at ${root}, package "${selected}": ${error instanceof Error ? error.message : String(error)} Repair/install the selected TypeScript package, or use explicit launch configuration; then refresh health. Reload after changing launch settings.`,
+      {
+        cause: error,
+        typescript: error instanceof TypeScriptLaunchError ? error.typescript : undefined,
+      },
+    );
+  }
+}
+
+/** Short-circuit on native metadata; validate only the winner's launch files later. */
+function selectAutomaticCompiler(probe: (name: string) => CompilerPackage | undefined): {
+  selected: string;
+  pkg?: CompilerPackage;
+} {
+  const canonical = probe("typescript");
+  if (canonical && compilerBackend(canonical) === "native")
+    return { selected: "typescript", pkg: canonical };
+  const native = probe("@typescript/native");
+  if (native) {
+    if (compilerBackend(native) !== "native")
+      throw new Error("@typescript/native must alias the stable native typescript package.");
+    return { selected: "@typescript/native", pkg: native };
+  }
+  if (canonical) return { selected: "typescript", pkg: canonical };
+  return { selected: "@typescript/typescript6", pkg: probe("@typescript/typescript6") };
+}
+
+/** Determine launch authority and reject conflicting selectors without probing installations. */
+export function isManualTypeScriptLaunch(config: ServerConfig, root: string): boolean {
+  const fields = config.typescriptExplicitFields ?? { command: "programmatic configuration" };
+  const tsserver = record(record(config.initializationOptions)?.tsserver);
+  const conflicts = [
+    ...(fields.command ? [`command (${fields.command})`] : []),
+    ...(fields.args ? [`args (${fields.args})`] : []),
+    ...(tsserver && Object.hasOwn(tsserver, "path")
+      ? [
+          `initializationOptions.tsserver.path (${fields.tsserverPath ?? "programmatic configuration"})`,
+        ]
+      : []),
+  ];
+  if (config.typescriptPackage !== undefined && conflicts.length) {
+    throw new Error(
+      `TypeScript launch at ${root}: typescriptPackage "${config.typescriptPackage}" (${fields.typescriptPackage ?? "programmatic configuration"}) conflicts with ${conflicts.join(", ")}. Remove the selector or the explicit launch fields and reload.`,
+    );
+  }
+  return conflicts.length > 0;
+}
+
+/** Classify consulted metadata before considering a lower-priority candidate. */
+function compilerBackend(pkg: CompilerPackage): "native" | "tsserver" {
+  if (pkg.name === "@typescript/typescript6" && !pkg.version) return "tsserver";
+  if (pkg.name === "typescript" && !pkg.version)
+    throw new Error(
+      `Selected implementation at ${pkg.directory} has no compiler version in package.json.`,
+    );
+  const version = pkg.version && !prerelease(pkg.version) ? major(pkg.version) : undefined;
+  if (pkg.name === "@typescript/typescript6" && version === 6) return "tsserver";
+  if (pkg.name === "typescript" && version !== undefined && version <= 7)
+    return version === 7 ? "native" : "tsserver";
+  throw new Error(
+    `Unsupported automatic TypeScript backend ${pkg.name ?? "(unknown identity)"} ${pkg.version ?? "(unknown version)"}. Select an installed stable TS7 or legacy TypeScript package with typescriptPackage, or configure command/args manually.`,
+  );
+}
+
+function compilerLaunch(
+  initializationOptions: unknown,
+  selectedPackage: CompilerPackage,
+  selected: string,
+): TypeScriptLaunch {
+  let pkg = selectedPackage;
+  const backend = compilerBackend(pkg);
+  if (backend === "native") return nativeLaunch(initializationOptions, pkg, selected);
+  const wrapper = pkg.name === "@typescript/typescript6" ? pkg : undefined;
+  if (wrapper) {
+    const underlying = findPackage("@typescript/old", wrapper.directory);
+    if (!underlying)
+      throw new Error(`Wrapper at ${wrapper.directory} has no @typescript/old dependency.`);
+    pkg = underlying;
+  }
+  // TLS ignores an explicit path without implementation version metadata and
+  // tries other installations. Fail here rather than report a compiler it won't use.
+  if (!pkg.version)
+    throw new Error(
+      `Selected implementation at ${pkg.directory} has no compiler version in package.json; TLS would ignore this selection.`,
+    );
+  if (compilerBackend(pkg) !== "tsserver" || pkg.name !== "typescript")
+    throw new Error(`Wrapper implementation at ${pkg.directory} must be legacy TypeScript.`);
+  const serverPath = path.join(pkg.directory, "lib/tsserver.js");
+  if (!fs.statSync(serverPath).isFile()) throw new Error(`No tsserver.js at ${serverPath}.`);
+  const options = record(initializationOptions);
+  const tsserver = record(options?.tsserver);
+  return {
+    initializationOptions: { ...options, tsserver: { ...tsserver, path: serverPath } },
+    typescript: {
+      backend: "tsserver",
+      packageName: selected,
+      compilerVersion: pkg.version,
+      ...(wrapper?.version ? { wrapperVersion: wrapper.version } : {}),
+    },
+  };
+}
+
+function nativeLaunch(
+  initializationOptions: unknown,
+  pkg: CompilerPackage,
+  selected: string,
+): TypeScriptLaunch {
+  const typescript: TypeScriptSelection = {
+    backend: "native",
+    packageName: selected,
+    compilerVersion: pkg.version,
+  };
+  try {
+    return {
+      command: process.execPath,
+      args: [nativeLauncher(pkg), "--lsp", "--stdio"],
+      initializationOptions,
+      typescript,
+    };
+  } catch (error) {
+    throw new TypeScriptLaunchError(error instanceof Error ? error.message : String(error), {
+      cause: error,
+      typescript,
+    });
+  }
+}
+
+function nativeLauncher(pkg: CompilerPackage): string {
+  const executable = record(pkg.bin)?.tsc;
+  if (typeof executable !== "string" || !executable || path.isAbsolute(executable))
+    throw new Error(
+      `Native package at ${pkg.directory} must declare a relative bin.tsc executable.`,
+    );
+  const launcher = path.resolve(pkg.directory, executable);
+  const relative = path.relative(pkg.directory, launcher);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || !fs.statSync(launcher).isFile())
+    throw new Error(`Invalid native tsc executable at ${launcher}.`);
+  return launcher;
+}
+
+/** Non-throwing selection probe shared by discovery and missing-server reporting. */
+export function inspectTypeScriptLaunch(
+  name: string,
+  config: ServerConfig,
+  root: string,
+): Pick<TypeScriptLaunch, "typescript"> & { command: string; failureMessage?: string } {
+  try {
+    const { command, typescript } = resolveTypeScriptLaunch(name, config, root);
+    return { command: command ?? config.command, ...(typescript ? { typescript } : {}) };
+  } catch (error) {
+    const typescript = error instanceof TypeScriptLaunchError ? error.typescript : undefined;
+    return {
+      command: typescript?.backend === "native" ? process.execPath : config.command,
+      ...(typescript ? { typescript } : {}),
+      failureMessage: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/diagnostics/evidence.ts

@@ -1,6 +1,6 @@
-/** Reason for a partial or unavailable single-file result when the push stays tentative. */
+/** Explain the lack of request-based confirmation when only ambient push evidence is available. */
 export const TENTATIVE_PUSH_UNAVAILABLE_REASON =
-  "A diagnostic publication is ambient evidence only; it may show issues, but an empty publication cannot confirm that the document is clean.";
+  "Only ambient push diagnostics are available for this file; completion of the diagnostic check cannot be confirmed. An empty publication cannot confirm that the document is clean.";
 
 /** A final evidence state for one tracked document. */
 export type DiagnosticEvidenceStatus = "confirmed" | "unconfirmed" | "failed" | "removed";

package/src/manager/manager-project-info.ts

@@ -1,6 +1,10 @@
 import type { LspClient } from "../client/client.ts";
 import { getServerOperationSupport } from "../config/operation-support.ts";
-import type { ProjectServerInfo, ProjectServerStatusReason } from "../config/server-config.ts";
+import type {
+  ProjectServerInfo,
+  ProjectServerStatusReason,
+  TypeScriptSelection,
+} from "../config/server-config.ts";
 import { displayRelativeFilePath } from "../summary.ts";
 
 interface ProjectServerInfoInput {
@@ -10,29 +14,37 @@ interface ProjectServerInfoInput {
   client: LspClient | undefined;
   unavailableReason?: "missing-command" | "start-failed" | "runtime-error";
   statusReason?: ProjectServerStatusReason;
+  typescript?: TypeScriptSelection;
+  failureMessage?: string;
   /** Filter files from ambient project status without changing explicit routing. */
   includeOpenFile?: (file: string) => boolean;
 }
 
+function projectStatus(input: ProjectServerInfoInput): ProjectServerInfo["status"] {
+  if (input.statusReason || input.failureMessage) return "error";
+  if (input.client?.status === "running") return "running";
+  if (
+    input.client?.status === "error" ||
+    input.unavailableReason === "start-failed" ||
+    input.unavailableReason === "runtime-error"
+  )
+    return "error";
+  return "unavailable";
+}
+
 export function buildProjectServerInfo(
   input: ProjectServerInfoInput,
   cwd: string,
 ): ProjectServerInfo {
-  const status = input.statusReason
-    ? "error"
-    : input.client?.status === "running"
-      ? "running"
-      : input.client?.status === "error" || input.unavailableReason === "start-failed"
-        ? "error"
-        : input.unavailableReason === "runtime-error"
-          ? "error"
-          : "unavailable";
+  const status = projectStatus(input);
 
   return {
     name: input.serverName,
     root: input.root,
     fileTypes: input.fileTypes,
     status,
+    ...(input.typescript ? { typescript: input.typescript } : {}),
+    ...(input.failureMessage ? { failureMessage: input.failureMessage } : {}),
     ...(input.statusReason ? { statusReason: input.statusReason } : {}),
     openFiles:
       input.client?.openFiles

package/src/manager/manager-workspace-symbol.ts

@@ -1,4 +1,4 @@
-import { statSync } from "node:fs";
+import { type Dirent, realpathSync, statSync } from "node:fs";
 import * as path from "node:path";
 import {
   type CodeQueryResult,
@@ -25,6 +25,10 @@ type WorkspaceSymbolLike = SymbolInformation | WorkspaceSymbol;
 
 const DEFAULT_WARM_FILE_DEPTH = 4;
 const DEFAULT_MARKER_SCAN_DEPTH = 6;
+/** Candidates per marker root; later candidates help only when earlier ones land outside the project. */
+const WARM_FILES_PER_ROOT = 3;
+/** Conventional source directories tried before other top-level entries. */
+const PREFERRED_SOURCE_DIRECTORIES = ["src", "lib", "app"];
 
 export interface WorkspaceSymbolWarmTarget {
   projectRoot: string;
@@ -63,6 +67,26 @@ export interface WorkspaceSymbolCollection {
   excludedCount?: number;
   /** Bounded paths removed by the automatic path policy. */
   excludedExamples?: string[];
+  /** Known coverage limits: the server may not have loaded every project in scope. */
+  coverageGap?: string;
+}
+
+/**
+ * Mark a collection whose warm-up never reached a configured project.
+ * The server answered only from inferred projects of the opened probe files,
+ * so an empty or short result does not prove a symbol is absent.
+ */
+export function workspaceSymbolCoverageGap(
+  collection: WorkspaceSymbolCollection,
+  inferredProbeCount: number,
+): WorkspaceSymbolCollection {
+  const noun = `file${inferredProbeCount === 1 ? "" : "s"}`;
+  return {
+    ...collection,
+    coverageGap:
+      `Workspace-symbol coverage is limited: ${inferredProbeCount} opened warm-up ${noun} ` +
+      "loaded only inferred projects, not a configured project. Open a project source file and retry.",
+  };
 }
 
 export async function collectWorkspaceSymbols(
@@ -96,10 +120,8 @@ function workspaceSymbolExclusionReason(collection: WorkspaceSymbolCollection):
   const excludedCount = collection.excludedCount ?? 0;
   if (excludedCount === 0) return null;
   const noun = `workspace-symbol result${excludedCount === 1 ? "" : "s"}`;
-  const examples = collection.excludedExamples?.length
-    ? ` Examples: ${collection.excludedExamples.join(", ")}.`
-    : "";
-  return `Automatic path policy excluded ${excludedCount} ${noun}.${examples}`;
+  // Paths belong to typed metadata so consumers can distinguish observed aliases from navigation.
+  return `Automatic path policy excluded ${excludedCount} ${noun}.`;
 }
 
 /** Project one multi-client collection into the shared typed query contract. */
@@ -115,8 +137,9 @@ export function workspaceSymbolCollectionResult(
     );
   }
   const exclusion = workspaceSymbolExclusionReason(collection);
-  if (collection.failures.length > 0 || exclusion) {
+  if (collection.failures.length > 0 || exclusion || collection.coverageGap) {
     const excludedCount = collection.excludedCount ?? 0;
+    const exclusionOnly = collection.failures.length === 0 && !collection.coverageGap;
     const metadata =
       excludedCount > 0
         ? {
@@ -124,17 +147,30 @@ export function workspaceSymbolCollectionResult(
               excludedCount,
               examples: [...(collection.excludedExamples ?? [])],
             },
+            ...(exclusionOnly ? { exclusionOnly: true } : {}),
           }
         : undefined;
     return partialCodeQuery(
       collection.results,
-      [collection.failures.join("; "), exclusion].filter(Boolean).join("; "),
+      [collection.failures.join("; "), collection.coverageGap, exclusion]
+        .filter(Boolean)
+        .join("; "),
       metadata,
     );
   }
   return completedCodeQuery(collection.results);
 }
 
+/**
+ * Choose files to open so a workspace-symbol server loads the projects under `root`.
+ *
+ * Returns up to three candidates per marker root, interleaved so every root's
+ * best candidate comes before any root's fallback; nested roots first. Within a
+ * root, conventional source directories come first and hidden entries last:
+ * root-level dotfiles and tool configs are often outside the configured program
+ * (for example `tsconfig.json` `include`), and opening only such a file loads an
+ * unrelated project. Callers try candidates in order.
+ */
 export function findWorkspaceSymbolWarmTargets(
   root: string,
   rootMarkers: string[],
@@ -158,7 +194,7 @@ export function findWorkspaceSymbolWarmTargets(
       return searchRoot
         ? findWorkspaceSymbolWarmTargets(searchRoot, rootMarkers, fileTypes, {
             ...options,
-            policy,
+            policy: explicitScopePolicy(policy, scope),
             scopes: undefined,
           })
         : [];
@@ -174,26 +210,76 @@ export function findWorkspaceSymbolWarmTargets(
   }
 
   const markerRoots = collectMarkerRoots(resolvedRoot, rootMarkers, maxMarkerDepth, policy);
-  const targets = markerRoots
-    .map((entry) => {
-      const file = findWarmFileRecursive(entry.root, allowed, maxFileDepth, policy);
-      return file ? { projectRoot: entry.root, file, priority: entry.priority } : null;
-    })
-    .filter((entry): entry is { projectRoot: string; file: string; priority: number } =>
-      Boolean(entry),
-    )
+  const perRoot = markerRoots
     .sort(
       (a, b) =>
-        a.priority - b.priority ||
-        a.projectRoot.length - b.projectRoot.length ||
-        a.projectRoot.localeCompare(b.projectRoot),
+        a.priority - b.priority || a.root.length - b.root.length || a.root.localeCompare(b.root),
     )
-    .map(({ projectRoot, file }) => ({ projectRoot, file }));
+    .map((entry) =>
+      findWarmFiles(entry.root, allowed, maxFileDepth, policy).map((file) => ({
+        projectRoot: entry.root,
+        file,
+      })),
+    );
+  // Interleave by rank so each root's best candidate precedes any root's fallback.
+  const targets = Array.from({ length: WARM_FILES_PER_ROOT }, (_, rank) =>
+    perRoot.flatMap((candidates) => candidates[rank] ?? []),
+  ).flat();
+
+  if (targets.length > 0) {
+    // Keep the first, most specific root for a file a parent root also reaches.
+    const seen = new Set<string>();
+    return targets.filter((target) => !seen.has(target.file) && Boolean(seen.add(target.file)));
+  }
 
-  if (targets.length > 0) return targets;
+  return findWarmFiles(resolvedRoot, allowed, maxFileDepth, policy).map((file) => ({
+    projectRoot: resolvedRoot,
+    file,
+  }));
+}
+
+/**
+ * True when a reported file is inside a scope by spelling or physical identity.
+ * Servers may report realpaths for files requested through symlinked roots.
+ */
+export function isWithinAnyScope(file: string, scopes: readonly string[]): boolean {
+  if (scopes.some((scope) => isWithinOrEqual(scope, file))) return true;
+  try {
+    const physicalFile = realpathSync(file);
+    return scopes.some((scope) => {
+      try {
+        return isWithinOrEqual(realpathSync(scope), physicalFile);
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return false;
+  }
+}
 
-  const fallback = findWarmFileRecursive(resolvedRoot, allowed, maxFileDepth, policy);
-  return fallback ? [{ projectRoot: resolvedRoot, file: fallback }] : [];
+/**
+ * Keep an explicitly selected excluded file or directory warmable, matching the
+ * rows workspace-symbol filtering allows for that scope. Exclusions nested in an
+ * eligible directory scope stay excluded.
+ */
+function explicitScopePolicy(
+  policy: AutomaticLspPathPolicy,
+  scope: string,
+): AutomaticLspPathPolicy {
+  const kind = statSync(scope, { throwIfNoEntry: false });
+  if (!kind) return policy;
+  const selected = kind.isFile()
+    ? (candidate: string) => path.resolve(candidate) === path.resolve(scope)
+    : policy.isEligible(scope, "directory")
+      ? null
+      : (candidate: string) => isWithinOrEqual(scope, candidate);
+  if (!selected) return policy;
+  return {
+    ...policy,
+    isEligible: (candidate, candidateKind) =>
+      selected(candidate) ? true : policy.isEligible(candidate, candidateKind),
+  };
 }
 
 interface MarkerRootEntry {
@@ -234,6 +320,54 @@ function collectMarkerRoots(
   }));
 }
 
+/**
+ * Pick at most {@link WARM_FILES_PER_ROOT} files under `root`, one per top-level
+ * group: preferred source directories, other directories, root files, then
+ * hidden entries.
+ */
+function findWarmFiles(
+  root: string,
+  allowed: Set<string>,
+  depth: number,
+  policy: AutomaticLspPathPolicy,
+): string[] {
+  let topLevel: readonly Dirent[] = [];
+  walkAutomaticLspTree(policy, root, 0, (_directory, entries) => {
+    topLevel = entries;
+    return true;
+  });
+  const isAllowedFile = (entry: Dirent) =>
+    (entry.isFile() || entry.isSymbolicLink()) &&
+    allowed.has(path.extname(entry.name).slice(1).toLowerCase());
+  const rank = (entry: Dirent) => {
+    const hidden = entry.name.startsWith(".") ? 3 : 0;
+    if (!entry.isDirectory()) return hidden + 2;
+    return hidden + (PREFERRED_SOURCE_DIRECTORIES.includes(entry.name) ? 0 : 1);
+  };
+  const ordered = topLevel
+    .filter((entry) => entry.isDirectory() || isAllowedFile(entry))
+    .map((entry, index) => ({ entry, index, rank: rank(entry) }))
+    .sort((a, b) => a.rank - b.rank || a.index - b.index);
+
+  const files: string[] = [];
+  const rootFileRanks = new Set<number>();
+  for (const { entry, rank: entryRank } of ordered) {
+    if (files.length >= WARM_FILES_PER_ROOT) break;
+    const entryPath = path.join(root, entry.name);
+    if (!entry.isDirectory()) {
+      // One root file per visibility group is enough evidence for that group.
+      if (rootFileRanks.has(entryRank)) continue;
+      rootFileRanks.add(entryRank);
+      files.push(entryPath);
+      continue;
+    }
+    if (depth <= 0) continue;
+    const file = findWarmFileRecursive(entryPath, allowed, depth - 1, policy);
+    if (file) files.push(file);
+  }
+  return files;
+}
+
 function findWarmFileRecursive(
   directory: string,
   allowed: Set<string>,