@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

package/node_modules/pi-lens/dist/chunk-5W3R6LFT.js

@@ -0,0 +1,24 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/symbol-containment.js
+function findOwnerName(candidates, targetStart, targetEnd) {
+  let best;
+  for (const candidate of candidates) {
+    const span = candidate.endLine - candidate.startLine;
+    const targetSpan = targetEnd - targetStart;
+    const contains = candidate.startLine <= targetStart && candidate.endLine >= targetEnd && span > targetSpan;
+    if (!contains)
+      continue;
+    if (!best || span < best.endLine - best.startLine)
+      best = candidate;
+  }
+  return best?.name;
+}
+function buildQualifiedName(ownerName, symbolName) {
+  return ownerName ? `${ownerName}.${symbolName}` : void 0;
+}
+
+export {
+  findOwnerName,
+  buildQualifiedName
+};

package/node_modules/pi-lens/dist/chunk-64LU2OVH.js

@@ -0,0 +1,341 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  findNearestDirWithMarker
+} from "./chunk-Z6BB4JLQ.js";
+import {
+  isWindowsPath
+} from "./chunk-G3RLJYA2.js";
+
+// dist/clients/file-kinds.js
+import { basename, extname, win32 } from "node:path";
+import * as path from "node:path";
+var KIND_EXTENSIONS = {
+  clojure: [".clj", ".cljc", ".cljs", ".edn"],
+  cmake: [".cmake"],
+  csharp: [".cs"],
+  css: [".css", ".less", ".sass", ".scss"],
+  cue: [".cue"],
+  // From llvm-project/clang/lib/Driver/Types.cpp clang::driver::types::lookupTypeForExtension:
+  cxx: [
+    // C
+    ".c",
+    ".h",
+    // C++
+    ".c++",
+    ".cc",
+    ".cp",
+    ".cpp",
+    ".cxx",
+    ".hh",
+    ".hpp",
+    ".hxx",
+    // C++ include files
+    ".inl",
+    ".ipp",
+    ".tpp",
+    ".txx",
+    // C++20 module interface files
+    ".c++m",
+    ".cppm",
+    ".cxxm",
+    ".ixx",
+    // CUDA
+    ".cu",
+    // HIP
+    ".hip",
+    // CUDA/HIP header convention; clang's driver table omits `.cuh`, but
+    // projects use it for C++ headers that must remain in the cxx kind (#2986).
+    ".cuh",
+    // Objective-C
+    ".m",
+    ".mm",
+    // OpenCL
+    ".cl",
+    ".clcpp"
+  ],
+  dart: [".dart"],
+  docker: [".dockerfile"],
+  elixir: [".ex", ".exs"],
+  fish: [".fish"],
+  fsharp: [".fs", ".fsi", ".fsx"],
+  gleam: [".gleam"],
+  go: [".go"],
+  haskell: [".hs", ".lhs"],
+  "helm-template": [".tpl"],
+  html: [".htm", ".html"],
+  java: [".java"],
+  json: [".json", ".json5", ".jsonc"],
+  jsts: [
+    ".cjs",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".mts",
+    ".svelte",
+    ".ts",
+    ".tsx",
+    ".vue"
+  ],
+  kotlin: [".kt", ".kts"],
+  lua: [".lua"],
+  markdown: [".md", ".mdx"],
+  nix: [".nix"],
+  ocaml: [".ml", ".mli"],
+  php: [".php"],
+  powershell: [".ps1", ".psm1", ".psd1"],
+  prisma: [".prisma"],
+  python: [".py", ".pyi"],
+  ruby: [".gemspec", ".rake", ".rb", ".ru"],
+  rust: [".rs"],
+  shell: [".bash", ".sh", ".zsh"],
+  sql: [".sql"],
+  swift: [".swift"],
+  terraform: [".tf", ".tfvars"],
+  terragrunt: [],
+  toml: [".toml"],
+  yaml: [".yaml", ".yml"],
+  zig: [".zig", ".zon"]
+};
+function hasKindExtension(filePath, kind) {
+  const extension = extname(filePath).toLowerCase();
+  return KIND_EXTENSIONS[kind].some((candidate) => candidate === extension);
+}
+var JSTS_FACT_EXTENSIONS = new Set(KIND_EXTENSIONS.jsts.filter((extension) => ![".vue", ".svelte"].includes(extension)));
+function isJstsFactFile(filePath) {
+  return JSTS_FACT_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+var NON_KIND_READABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".env",
+  ".cfg",
+  ".conf",
+  ".ini",
+  ".xml"
+]);
+function isReadableSourceFile(filePath) {
+  const extension = extname(filePath).toLowerCase();
+  return Object.keys(KIND_EXTENSIONS).some((kind) => hasKindExtension(filePath, kind)) || NON_KIND_READABLE_EXTENSIONS.has(extension);
+}
+var DOTNET_CSHARP_ROOT_MARKERS = [
+  "*.csproj",
+  "*.sln",
+  "*.slnx"
+];
+var DOTNET_FSHARP_ROOT_MARKERS = [
+  "*.fsproj",
+  "*.sln"
+];
+var TERRAGRUNT_FILENAMES = [
+  "terragrunt.hcl",
+  "root.hcl"
+];
+var EXT_TO_KIND = /* @__PURE__ */ new Map();
+for (const [kind, exts] of Object.entries(KIND_EXTENSIONS)) {
+  for (const ext of exts) {
+    EXT_TO_KIND.set(ext.toLowerCase(), kind);
+  }
+  for (const ext of exts) {
+    if (ext.startsWith(".")) {
+      EXT_TO_KIND.set(ext.slice(1).toLowerCase(), kind);
+    }
+  }
+}
+var SPECIAL_FILENAMES = [
+  { pattern: /^CMakeLists\.txt$/i, kind: "cmake" },
+  { pattern: /^Makefile$/i, kind: "shell" },
+  { pattern: /^Dockerfile(\.\w+)?$/i, kind: "docker" },
+  ...TERRAGRUNT_FILENAMES.map((name) => ({
+    pattern: new RegExp(`^${name.replaceAll(".", "\\.")}$`, "i"),
+    kind: "terragrunt"
+  }))
+];
+function isHelmYamlTemplatePath(filePath) {
+  const templatesSegment = isWindowsPath(filePath) ? /[\\/]templates[\\/]/i : /\/templates\//i;
+  if (!templatesSegment.test(filePath) || !/\.ya?ml$/i.test(filePath)) {
+    return false;
+  }
+  const pathApi = isWindowsPath(filePath) ? win32 : path;
+  return Boolean(findNearestDirWithMarker(pathApi.dirname(filePath), "chartYamlPath"));
+}
+function detectFileKind(filePath) {
+  if (!filePath || typeof filePath !== "string") {
+    return void 0;
+  }
+  if (isHelmYamlTemplatePath(filePath)) {
+    return "helm-template";
+  }
+  const base = basename(filePath);
+  for (const { pattern, kind } of SPECIAL_FILENAMES) {
+    if (pattern.test(base)) {
+      return kind;
+    }
+  }
+  const ext = extname(filePath).toLowerCase();
+  return EXT_TO_KIND.get(ext);
+}
+function isFileKind(filePath, kind) {
+  const detected = detectFileKind(filePath);
+  if (!detected)
+    return false;
+  if (Array.isArray(kind)) {
+    return kind.includes(detected);
+  }
+  return detected === kind;
+}
+function getFileKindsForExtension(ext) {
+  const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
+  const kind = EXT_TO_KIND.get(normalizedExt.toLowerCase());
+  return kind ? [kind] : [];
+}
+var CODE_KINDS = /* @__PURE__ */ new Set([
+  "clojure",
+  "cmake",
+  "csharp",
+  "cue",
+  "cxx",
+  "dart",
+  "docker",
+  "elixir",
+  "fish",
+  "fsharp",
+  "gleam",
+  "go",
+  "haskell",
+  "helm-template",
+  "java",
+  "jsts",
+  "kotlin",
+  "lua",
+  "nix",
+  "ocaml",
+  "php",
+  "powershell",
+  "prisma",
+  "python",
+  "ruby",
+  "rust",
+  "shell",
+  "sql",
+  "swift",
+  "terraform",
+  "terragrunt",
+  "zig"
+]);
+var NON_CODE_KINDS = /* @__PURE__ */ new Set([
+  "css",
+  "html",
+  "json",
+  "markdown",
+  "toml",
+  "yaml"
+]);
+function isCodeKindFile(filePath) {
+  const kind = detectFileKind(filePath);
+  return kind !== void 0 && CODE_KINDS.has(kind);
+}
+function getFileKindLabel(kind) {
+  const labels = {
+    jsts: "JavaScript/TypeScript",
+    python: "Python",
+    go: "Go",
+    rust: "Rust",
+    cxx: "C/C++",
+    cmake: "CMake",
+    shell: "Shell",
+    json: "JSON",
+    markdown: "Markdown",
+    css: "CSS",
+    yaml: "YAML",
+    sql: "SQL",
+    ruby: "Ruby",
+    html: "HTML",
+    docker: "Dockerfile",
+    php: "PHP",
+    powershell: "PowerShell",
+    prisma: "Prisma",
+    csharp: "C#",
+    fish: "Fish shell",
+    fsharp: "F#",
+    java: "Java",
+    kotlin: "Kotlin",
+    swift: "Swift",
+    dart: "Dart",
+    lua: "Lua",
+    zig: "Zig",
+    haskell: "Haskell",
+    "helm-template": "Helm template",
+    elixir: "Elixir",
+    gleam: "Gleam",
+    ocaml: "OCaml",
+    clojure: "Clojure",
+    cue: "CUE",
+    terraform: "Terraform",
+    terragrunt: "Terragrunt",
+    nix: "Nix",
+    toml: "TOML"
+  };
+  return labels[kind] ?? kind;
+}
+function getLanguageId(kind) {
+  const languageIds = {
+    jsts: "typescript",
+    python: "python",
+    go: "go",
+    rust: "rust",
+    cxx: "cpp",
+    cmake: "cmake",
+    shell: "shell",
+    json: "json",
+    markdown: "markdown",
+    css: "css",
+    yaml: "yaml",
+    sql: "sql",
+    ruby: "ruby",
+    html: "html",
+    docker: "dockerfile",
+    php: "php",
+    powershell: "powershell",
+    prisma: "prisma",
+    csharp: "csharp",
+    fish: "fish",
+    fsharp: "fsharp",
+    java: "java",
+    kotlin: "kotlin",
+    swift: "swift",
+    dart: "dart",
+    lua: "lua",
+    zig: "zig",
+    haskell: "haskell",
+    "helm-template": "helm",
+    elixir: "elixir",
+    gleam: "gleam",
+    ocaml: "ocaml",
+    clojure: "clojure",
+    cue: "cue",
+    terraform: "terraform",
+    terragrunt: "terragrunt",
+    nix: "nix",
+    toml: "toml"
+  };
+  return languageIds[kind] ?? "plaintext";
+}
+
+export {
+  KIND_EXTENSIONS,
+  isJstsFactFile,
+  isReadableSourceFile,
+  DOTNET_CSHARP_ROOT_MARKERS,
+  DOTNET_FSHARP_ROOT_MARKERS,
+  TERRAGRUNT_FILENAMES,
+  SPECIAL_FILENAMES,
+  isHelmYamlTemplatePath,
+  detectFileKind,
+  isFileKind,
+  getFileKindsForExtension,
+  CODE_KINDS,
+  NON_CODE_KINDS,
+  isCodeKindFile,
+  getFileKindLabel,
+  getLanguageId
+};

package/node_modules/pi-lens/dist/chunk-6B5I6ICN.js

@@ -0,0 +1,44 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  MAX_STARTUP_SCAN_ENTRIES,
+  __testing,
+  _resetStartupScanMaxEntriesForTests,
+  _resetStartupScanVerdictTtlForTests,
+  countSourceFilesWithinLimit,
+  countSourceFilesWithinLimitAsync,
+  findNearestProjectRoot,
+  getStartupScanMaxEntries,
+  getStartupScanVerdictTtlMs,
+  isStartupScanVerdictFresh,
+  resolveStartupScanContext,
+  resolveStartupScanContextAsync
+} from "./chunk-6P54TMWL.js";
+import "./chunk-IUKPRZER.js";
+import "./chunk-H5EV3VMF.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  MAX_STARTUP_SCAN_ENTRIES,
+  __testing,
+  _resetStartupScanMaxEntriesForTests,
+  _resetStartupScanVerdictTtlForTests,
+  countSourceFilesWithinLimit,
+  countSourceFilesWithinLimitAsync,
+  findNearestProjectRoot,
+  getStartupScanMaxEntries,
+  getStartupScanVerdictTtlMs,
+  isStartupScanVerdictFresh,
+  resolveStartupScanContext,
+  resolveStartupScanContextAsync
+};

package/node_modules/pi-lens/dist/chunk-6P54TMWL.js

@@ -0,0 +1,274 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  getStartupScanMaxSourceFilesDerived
+} from "./chunk-IUKPRZER.js";
+import {
+  shouldRecurseIntoDir,
+  walkTreeStackAsync,
+  walkTreeStackSync
+} from "./chunk-H5EV3VMF.js";
+import {
+  getProjectIgnoreMatcher
+} from "./chunk-T54VJRAD.js";
+import {
+  getDirectoryMarkers,
+  registerWorkspaceTopologyReset
+} from "./chunk-Z6BB4JLQ.js";
+import {
+  lazyEnvNumber
+} from "./chunk-VSMJK3ZJ.js";
+import {
+  BoundedLruCache
+} from "./chunk-ABBOA7UD.js";
+import {
+  isAtOrAboveHomeDir,
+  normalizeMapKey
+} from "./chunk-G3RLJYA2.js";
+
+// dist/clients/startup-scan.js
+import * as os from "node:os";
+import * as path from "node:path";
+var PROJECT_ROOT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "composer.json"
+];
+var MAX_STARTUP_SCAN_ENTRIES = 5e4;
+var SOURCE_FILE_PATTERN = /\.(ts|tsx|js|jsx|py|go|rs|rb)$/;
+var DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS = 24 * 60 * 60 * 1e3;
+var _ttl = lazyEnvNumber("PI_LENS_STARTUP_SCAN_VERDICT_TTL_MS", DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS);
+var getStartupScanVerdictTtlMs = _ttl.get;
+var _resetStartupScanVerdictTtlForTests = _ttl._resetForTests;
+var _maxEntries = lazyEnvNumber("PI_LENS_STARTUP_SCAN_MAX_ENTRIES", MAX_STARTUP_SCAN_ENTRIES);
+var getStartupScanMaxEntries = _maxEntries.get;
+var _resetStartupScanMaxEntriesForTests = _maxEntries._resetForTests;
+function isStartupScanVerdictFresh(verdict, now = Date.now()) {
+  if (verdict.reason !== "too-many-source-files" && verdict.reason !== "too-many-entries")
+    return true;
+  if (typeof verdict.computedAt !== "number")
+    return false;
+  if (verdict.maxProjectFiles !== getStartupScanMaxSourceFilesDerived(verdict.cwd))
+    return false;
+  if (verdict.maxScanEntries !== getStartupScanMaxEntries())
+    return false;
+  return now - verdict.computedAt < getStartupScanVerdictTtlMs();
+}
+function findNearestProjectRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    const entryNames = getDirectoryMarkers(current).entryNames;
+    if (PROJECT_ROOT_MARKERS.some((marker) => entryNames.has(marker))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries) {
+  return (entry, fullPath) => {
+    state.visited += 1;
+    if (entry.isDirectory()) {
+      const recurse = shouldRecurseIntoDir(entry, fullPath, {
+        ignoreMatcher,
+        followSymlinks: true
+      });
+      if (state.visited >= maxEntries) {
+        state.entryBudgetExceeded = true;
+        return "stop";
+      }
+      return recurse ? "recurse" : "skip";
+    }
+    if (entry.isFile() && SOURCE_FILE_PATTERN.test(entry.name) && !ignoreMatcher.isIgnored(fullPath, false)) {
+      state.count += 1;
+      if (state.count > limit)
+        return "stop";
+    }
+    if (state.visited >= maxEntries) {
+      state.entryBudgetExceeded = true;
+      return "stop";
+    }
+    return "skip";
+  };
+}
+function walkSourceCount(dir, limit, maxEntries) {
+  const state = {
+    count: 0,
+    visited: 0,
+    entryBudgetExceeded: false
+  };
+  const rootDir = path.resolve(dir);
+  const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
+  walkTreeStackSync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries));
+  return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
+}
+function countSourceFilesWithinLimit(dir, limit) {
+  return walkSourceCount(dir, limit, Number.POSITIVE_INFINITY).count;
+}
+var startupScanContextCache = new BoundedLruCache(32);
+registerWorkspaceTopologyReset(() => startupScanContextCache.clear());
+function startupScanCacheKey(cwd, options) {
+  return [
+    normalizeMapKey(path.resolve(cwd)),
+    options.homeDir ? normalizeMapKey(path.resolve(options.homeDir)) : "",
+    options.maxSourceFiles ?? "",
+    options.maxScanEntries ?? ""
+  ].join("|");
+}
+var __testing = { startupScanCacheKey };
+function resolveStartupScanContext(cwd, options = {}) {
+  const cacheKey = startupScanCacheKey(cwd, options);
+  const cached = startupScanContextCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const result = {
+    ...computeStartupScanContext(cwd, options),
+    computedAt: Date.now()
+  };
+  startupScanContextCache.set(cacheKey, result);
+  return result;
+}
+function computeStartupScanContext(cwd, options = {}) {
+  const resolvedCwd = path.resolve(cwd);
+  const homeDir = path.resolve(options.homeDir ?? os.homedir());
+  const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
+  const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
+  const projectRoot = findNearestProjectRoot(resolvedCwd);
+  if (!projectRoot) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: resolvedCwd,
+      projectRoot: null,
+      canWarmCaches: false,
+      reason: isAtOrAboveHomeDir(resolvedCwd, homeDir) ? "home-dir" : "no-project-root"
+    };
+  }
+  if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: "home-dir"
+    };
+  }
+  const { count: sourceFileCount, entryBudgetExceeded } = walkSourceCount(projectRoot, maxSourceFiles, maxScanEntries);
+  if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
+      sourceFileCount,
+      maxProjectFiles: maxSourceFiles,
+      maxScanEntries
+    };
+  }
+  return {
+    cwd: resolvedCwd,
+    scanRoot: projectRoot,
+    projectRoot,
+    canWarmCaches: true,
+    sourceFileCount
+  };
+}
+async function walkSourceCountAsync(dir, limit, maxEntries, opts = {}) {
+  const state = {
+    count: 0,
+    visited: 0,
+    entryBudgetExceeded: false
+  };
+  const rootDir = path.resolve(dir);
+  const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
+  await walkTreeStackAsync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries), {
+    // Yield every 100 entries by default. Empirically each yield costs
+    // ~0.1ms of overhead and a 2k-file project produces ~20 yields, so the
+    // total async overhead is well under 5ms while keeping per-burst sync
+    // work under 50ms (the perceptual threshold for "instant" keystrokes).
+    budgetMs: opts.budgetMs ?? 8,
+    // #703: prime the tracked-files set ONCE before the walk (not per file)
+    // so a tracked file matching a `.gitignore`/global pattern isn't dropped
+    // from the startup source-file count. Fail-open: resolves even when git
+    // is absent, and `isIgnored` degrades to pattern-only if this never
+    // resolves before a caller inspects results.
+    beforeWalk: () => ignoreMatcher.ensureTrackedIndex()
+  });
+  return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
+}
+async function countSourceFilesWithinLimitAsync(dir, limit, opts = {}) {
+  return (await walkSourceCountAsync(dir, limit, Number.POSITIVE_INFINITY, opts)).count;
+}
+async function resolveStartupScanContextAsync(cwd, options = {}) {
+  const cacheKey = startupScanCacheKey(cwd, options);
+  const cached = startupScanContextCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const resolvedCwd = path.resolve(cwd);
+  const homeDir = path.resolve(options.homeDir ?? os.homedir());
+  const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
+  const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
+  const projectRoot = findNearestProjectRoot(resolvedCwd);
+  let result;
+  if (!projectRoot) {
+    result = {
+      cwd: resolvedCwd,
+      scanRoot: resolvedCwd,
+      projectRoot: null,
+      canWarmCaches: false,
+      reason: isAtOrAboveHomeDir(resolvedCwd, homeDir) ? "home-dir" : "no-project-root"
+    };
+  } else if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
+    result = {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: "home-dir"
+    };
+  } else {
+    const { count: sourceFileCount, entryBudgetExceeded } = await walkSourceCountAsync(projectRoot, maxSourceFiles, maxScanEntries);
+    if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
+      result = {
+        cwd: resolvedCwd,
+        scanRoot: projectRoot,
+        projectRoot,
+        canWarmCaches: false,
+        reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
+        sourceFileCount,
+        maxProjectFiles: maxSourceFiles,
+        maxScanEntries
+      };
+    } else {
+      result = {
+        cwd: resolvedCwd,
+        scanRoot: projectRoot,
+        projectRoot,
+        canWarmCaches: true,
+        sourceFileCount
+      };
+    }
+  }
+  result = { ...result, computedAt: Date.now() };
+  startupScanContextCache.set(cacheKey, result);
+  return result;
+}
+
+export {
+  MAX_STARTUP_SCAN_ENTRIES,
+  getStartupScanVerdictTtlMs,
+  _resetStartupScanVerdictTtlForTests,
+  getStartupScanMaxEntries,
+  _resetStartupScanMaxEntriesForTests,
+  isStartupScanVerdictFresh,
+  findNearestProjectRoot,
+  countSourceFilesWithinLimit,
+  __testing,
+  resolveStartupScanContext,
+  countSourceFilesWithinLimitAsync,
+  resolveStartupScanContextAsync
+};