@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

package/node_modules/pi-lens/dist/chunk-QYF5S6P6.js

@@ -0,0 +1,45 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/cooperative-budget.js
+function createDeadline(budgetMs) {
+  const boundedBudget = Math.max(0, budgetMs);
+  let startedAt = performance.now();
+  return {
+    expired: () => performance.now() - startedAt >= boundedBudget,
+    reset: () => {
+      startedAt = performance.now();
+    }
+  };
+}
+async function yieldIfOverBudget(deadline) {
+  if (!deadline.expired())
+    return false;
+  await new Promise((resolve) => setImmediate(resolve));
+  deadline.reset();
+  return true;
+}
+async function forEachCooperatively(items, fn, options) {
+  const deadline = createDeadline(options.budgetMs);
+  const assertContinuing = () => {
+    if (options.shouldContinue?.() === false) {
+      throw new Error(options.abortMessage ?? "cooperative work superseded");
+    }
+  };
+  let index = 0;
+  for (const item of items) {
+    assertContinuing();
+    const result = fn(item, index++);
+    if (result !== void 0 && typeof result.then === "function") {
+      await result;
+    }
+    if (deadline.expired() && await yieldIfOverBudget(deadline)) {
+      assertContinuing();
+    }
+  }
+}
+
+export {
+  createDeadline,
+  yieldIfOverBudget,
+  forEachCooperatively
+};

package/node_modules/pi-lens/dist/chunk-RJFED73B.js

@@ -0,0 +1,79 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  LSPService,
+  __collectWorkspaceDiagnosticFilesForTest,
+  createSweepIndexGate,
+  getLSPService,
+  getLspClientCeiling,
+  getLspIdleEvictMs,
+  getLspIdleEvictMsForRoot,
+  groupFilesByPrimaryServer,
+  hasAuxiliaryLspPublishedForRoot,
+  mergeInitializationOptions,
+  notifyExternalFileChange,
+  peekLSPService,
+  resetLSPService,
+  resyncGitChangedFiles,
+  runPerServerGroups
+} from "./chunk-MTDRLSI7.js";
+import "./chunk-OZJINN4O.js";
+import "./chunk-3JSEWUWI.js";
+import "./chunk-XIMYZ3JA.js";
+import "./chunk-IQZXOZ7S.js";
+import "./chunk-LNOMA3MP.js";
+import "./chunk-U52SAGRM.js";
+import "./chunk-UEAHAMEI.js";
+import "./chunk-Z54ZSOBZ.js";
+import "./chunk-KJCWXUUS.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-6XX5HCLK.js";
+import "./chunk-S6AMWKPC.js";
+import "./chunk-F5VLZHUW.js";
+import "./chunk-AXKPQ6ZI.js";
+import "./chunk-7BX5DWSA.js";
+import "./chunk-IUKPRZER.js";
+import "./chunk-Z3CCVDUB.js";
+import "./chunk-XGUL4SLQ.js";
+import "./chunk-2BEMIWEW.js";
+import "./chunk-LD7WFTRX.js";
+import "./chunk-IUR76K6A.js";
+import "./chunk-T4QZ6FEH.js";
+import "./chunk-D6YF5HKX.js";
+import "./chunk-CMU4RMJB.js";
+import "./chunk-O7HZX7CA.js";
+import "./chunk-VYKKMYVT.js";
+import "./chunk-BNKLYOOO.js";
+import "./chunk-USHG4DLH.js";
+import "./chunk-H5EV3VMF.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-64LU2OVH.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 {
+  LSPService,
+  __collectWorkspaceDiagnosticFilesForTest,
+  createSweepIndexGate,
+  getLSPService,
+  getLspClientCeiling,
+  getLspIdleEvictMs,
+  getLspIdleEvictMsForRoot,
+  groupFilesByPrimaryServer,
+  hasAuxiliaryLspPublishedForRoot,
+  mergeInitializationOptions,
+  notifyExternalFileChange,
+  peekLSPService,
+  resetLSPService,
+  resyncGitChangedFiles,
+  runPerServerGroups
+};

package/node_modules/pi-lens/dist/chunk-RTQNRM5X.js

@@ -0,0 +1,27 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  GovulncheckClient,
+  parseGovulncheckJson
+} from "./chunk-N7YNJE5R.js";
+import "./chunk-5JHXUETW.js";
+import "./chunk-FGALODG3.js";
+import "./chunk-D6YF5HKX.js";
+import "./chunk-CMU4RMJB.js";
+import "./chunk-O7HZX7CA.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-BW5KFIQC.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 {
+  GovulncheckClient,
+  parseGovulncheckJson
+};

package/node_modules/pi-lens/dist/chunk-S6AMWKPC.js

@@ -0,0 +1,189 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  logExtension
+} from "./chunk-34OCDWOS.js";
+import {
+  findNearestMarkerRoot,
+  isAtOrAboveHomeDir
+} from "./chunk-G3RLJYA2.js";
+
+// dist/clients/cargo-manifest.js
+import { readFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+async function readTextFileOrUndefined(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function stripTomlLineComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "#")
+      return line.slice(0, i);
+  }
+  return line;
+}
+function normalizeToml(content) {
+  return content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").split("\n").map(stripTomlLineComment).join("\n");
+}
+function extractTomlTableSection(content, tableName) {
+  const normalized = normalizeToml(content);
+  const heading = new RegExp(`^[ \\t]*\\[${tableName}\\][ \\t]*(?:#.*)?$`, "m");
+  const match = heading.exec(normalized);
+  if (!match)
+    return void 0;
+  const rest = normalized.slice(match.index + match[0].length);
+  const nextHeading = rest.match(/^[ \t]*\[{1,2}[^\]]+\]{1,2}[ \t]*(?:#.*)?$/m);
+  return nextHeading?.index !== void 0 ? rest.slice(0, nextHeading.index) : rest;
+}
+function parseTomlStringArray(content, key) {
+  if (content === void 0)
+    return [];
+  const normalized = normalizeToml(content);
+  const open = normalized.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\[`, "m"));
+  if (open?.index === void 0)
+    return [];
+  const from = open.index + open[0].length;
+  const to = indexOfArrayEnd(normalized, from);
+  if (to < 0)
+    return [];
+  return [...normalized.slice(from, to).matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => (m[1] ?? m[2] ?? "").trim());
+}
+function indexOfArrayEnd(text, from) {
+  let quote = null;
+  for (let i = from; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "\\" && quote === '"')
+        i++;
+      else if (ch === quote)
+        quote = null;
+    } else if (ch === '"' || ch === "'")
+      quote = ch;
+    else if (ch === "]")
+      return i;
+  }
+  return -1;
+}
+function parseTomlScalarString(content, key) {
+  if (content === void 0)
+    return void 0;
+  const match = content.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*(?:"([^"]*)"|'([^']*)')`, "m"));
+  if (!match)
+    return void 0;
+  return match[1] ?? match[2];
+}
+function hasCargoWorkspaceTable(content) {
+  return hasTomlTable(content, "workspace");
+}
+function hasTomlTable(content, tableName) {
+  return extractTomlTableSection(content, tableName) !== void 0;
+}
+function readCargoPackageName(content) {
+  const packageSection = extractTomlTableSection(content, "package");
+  return parseTomlScalarString(packageSection, "name");
+}
+function readCargoWorkspaceMembers(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "members");
+}
+function readCargoWorkspaceExclude(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "exclude");
+}
+function readCargoDependencyNames(content) {
+  const section = extractTomlTableSection(content, "dependencies");
+  if (section === void 0)
+    return [];
+  const names = [];
+  for (const rawLine of section.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const match = line.match(/^([A-Za-z0-9_-]+)\s*=/);
+    if (match)
+      names.push(match[1]);
+  }
+  return names;
+}
+function isTomlKeyWorkspaceInherited(content, key) {
+  if (content === void 0)
+    return false;
+  const dotted = new RegExp(`^[ \\t]*${key}\\.workspace[ \\t]*=[ \\t]*true`, "m");
+  const inline = new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\{[^}\\n]*\\bworkspace[ \\t]*=[ \\t]*true`, "m");
+  return dotted.test(content) || inline.test(content);
+}
+var SUPPORTED_RUSTFMT_EDITIONS = /* @__PURE__ */ new Set(["2015", "2018", "2021", "2024"]);
+function validatedEdition(value, filePath) {
+  if (value === void 0)
+    return void 0;
+  if (SUPPORTED_RUSTFMT_EDITIONS.has(value))
+    return value;
+  logExtension({
+    subsystem: "format",
+    message: "resolveCargoPackageEdition: manifest edition is not a rustfmt-supported value; falling back to the static rustfmt command",
+    level: "debug",
+    metadata: { rejectedEdition: value, filePath }
+  });
+  return void 0;
+}
+function readWorkspacePackageEdition(content) {
+  const workspaceSection = extractTomlTableSection(content, "workspace.package");
+  return parseTomlScalarString(workspaceSection, "edition");
+}
+async function resolveCargoPackageEdition(filePath, homeDir = os.homedir()) {
+  const startDir = path.dirname(path.resolve(filePath));
+  const packageDir = findNearestMarkerRoot(startDir, ["Cargo.toml"], {
+    homeDir
+  });
+  if (!packageDir)
+    return void 0;
+  const packageContent = await readTextFileOrUndefined(path.join(packageDir, "Cargo.toml"));
+  if (packageContent === void 0)
+    return void 0;
+  const packageSection = extractTomlTableSection(packageContent, "package");
+  const direct = parseTomlScalarString(packageSection, "edition");
+  if (direct !== void 0)
+    return validatedEdition(direct, filePath);
+  if (!isTomlKeyWorkspaceInherited(packageSection, "edition"))
+    return void 0;
+  if (hasCargoWorkspaceTable(packageContent)) {
+    return validatedEdition(readWorkspacePackageEdition(packageContent), filePath);
+  }
+  let current = path.dirname(packageDir);
+  for (let depth = 0; depth < 64; depth++) {
+    if (isAtOrAboveHomeDir(current, homeDir))
+      return void 0;
+    const ancestorContent = await readTextFileOrUndefined(path.join(current, "Cargo.toml"));
+    if (ancestorContent !== void 0 && hasCargoWorkspaceTable(ancestorContent)) {
+      return validatedEdition(readWorkspacePackageEdition(ancestorContent), filePath);
+    }
+    const parent = path.dirname(current);
+    if (parent === current)
+      return void 0;
+    current = parent;
+  }
+  return void 0;
+}
+
+export {
+  readTextFileOrUndefined,
+  extractTomlTableSection,
+  parseTomlStringArray,
+  hasCargoWorkspaceTable,
+  hasTomlTable,
+  readCargoPackageName,
+  readCargoWorkspaceMembers,
+  readCargoWorkspaceExclude,
+  readCargoDependencyNames,
+  resolveCargoPackageEdition
+};

package/node_modules/pi-lens/dist/chunk-T4QZ6FEH.js

@@ -0,0 +1,308 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createAvailabilityProbeFlight,
+  probeToolAsync
+} from "./chunk-CMU4RMJB.js";
+import {
+  classifyProbeFailure,
+  createAvailabilityLatch,
+  isTransientDecision,
+  logAvailabilityDecision,
+  startHostStallSampler
+} from "./chunk-O7HZX7CA.js";
+import {
+  createGenerationSource,
+  safeSpawnAsync
+} from "./chunk-T54VJRAD.js";
+import {
+  isAtOrAboveHomeDir,
+  walkUpDirs
+} from "./chunk-G3RLJYA2.js";
+
+// dist/clients/package-manager.js
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var PREFERENCE = [
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun"
+];
+var packageManagerProbeFlights = createAvailabilityProbeFlight();
+function onWindows() {
+  return process.platform === "win32";
+}
+function isNodePackageManager(value) {
+  return value === "npm" || value === "pnpm" || value === "yarn" || value === "bun";
+}
+function detectNodePackageManager(targetPath) {
+  if (fs.existsSync(path.join(targetPath, "bun.lockb")) || fs.existsSync(path.join(targetPath, "bun.lock"))) {
+    return "bun";
+  }
+  if (fs.existsSync(path.join(targetPath, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs.existsSync(path.join(targetPath, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (fs.existsSync(path.join(targetPath, "package-lock.json"))) {
+    return "npm";
+  }
+  return readPackageManagerField(targetPath);
+}
+function readPackageManagerField(targetPath) {
+  try {
+    const pkgPath = path.join(targetPath, "package.json");
+    if (!fs.existsSync(pkgPath))
+      return void 0;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (typeof pkg.packageManager !== "string")
+      return void 0;
+    const name = pkg.packageManager.split("@")[0].trim().toLowerCase();
+    return isNodePackageManager(name) ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var PROBE_TIMEOUT_MS = 5e3;
+var availabilityLatches = /* @__PURE__ */ new Map();
+function getLatch(pm) {
+  let latch = availabilityLatches.get(pm);
+  if (!latch) {
+    latch = createAvailabilityLatch();
+    availabilityLatches.set(pm, latch);
+  }
+  return latch;
+}
+async function probeAvailability(pm) {
+  const latch = getLatch(pm);
+  const startedAt = Date.now();
+  const finder = onWindows() ? "where" : "which";
+  const sampler = startHostStallSampler();
+  let result;
+  let hostStallMs;
+  try {
+    result = await probeToolAsync(finder, [pm], { timeout: PROBE_TIMEOUT_MS });
+  } finally {
+    hostStallMs = sampler.stop();
+  }
+  const elapsedMs = Date.now() - startedAt;
+  if (result.status === 0 && !result.error) {
+    latch.noteAvailable();
+    logAvailabilityDecision({
+      tool: pm,
+      verdict: "available",
+      outcome: "success",
+      cause: "ok",
+      elapsedMs,
+      latched: true,
+      hostStallMs,
+      budgetMs: PROBE_TIMEOUT_MS,
+      classifiedBy: "probe"
+    });
+    return true;
+  }
+  const { outcome, cause, evidence } = classifyProbeFailure(result, {
+    hostStallMs,
+    // Preserve pre-#1496 meaning for anything the classifier can't place: a
+    // present manager that rejects its probe is durable, same as before.
+    unclassifiedFailureOutcome: "missing"
+  });
+  const retryAfterMs = latch.noteUnavailable(outcome, cause);
+  logAvailabilityDecision({
+    tool: pm,
+    verdict: "unavailable",
+    outcome,
+    cause,
+    elapsedMs,
+    latched: outcome !== "transient",
+    hostStallMs,
+    ...retryAfterMs > 0 && { retryAfterMs },
+    budgetMs: PROBE_TIMEOUT_MS,
+    classifiedBy: "probe",
+    evidence
+  });
+  return false;
+}
+function isAvailable(pm, onTransient) {
+  const latch = getLatch(pm);
+  const reportIfTransient = (result) => {
+    if (!result && isTransientDecision({ outcome: latch.getOutcome() })) {
+      onTransient?.();
+    }
+    return result;
+  };
+  const memo = latch.read();
+  if (memo !== null)
+    return Promise.resolve(reportIfTransient(memo));
+  const shared = packageManagerProbeFlights.run(`package-manager:${pm}`, () => probeAvailability(pm));
+  return shared.promise.then(reportIfTransient);
+}
+function _resetPackageManagerCache() {
+  packageManagerCacheGeneration.bump();
+  availabilityLatches.clear();
+  packageManagerProbeFlights.clear();
+  globalBinDirCache.clear();
+  globalBinDirProbeFlights.clear();
+}
+async function resolveNodePackageManager(cwd = process.cwd()) {
+  const declared = detectNodePackageManager(cwd);
+  if (declared && await isAvailable(declared)) {
+    return declared;
+  }
+  for (const pm of PREFERENCE) {
+    if (await isAvailable(pm))
+      return pm;
+  }
+  return "npm";
+}
+function pmBinary(pm) {
+  if (!onWindows())
+    return pm;
+  return pm === "bun" ? "bun.exe" : `${pm}.cmd`;
+}
+function runScriptArgs(script) {
+  return ["run", script];
+}
+function installArgs(pm, pkg, options = {}) {
+  const args = [pm === "npm" ? "install" : "add"];
+  if (options.ignoreScripts)
+    args.push("--ignore-scripts");
+  if (options.legacyPeerDeps && pm === "npm")
+    args.push("--legacy-peer-deps");
+  args.push(pkg);
+  return args;
+}
+function updateArgs(pm, pkg, options = {}) {
+  const args = [pm === "yarn" ? "upgrade" : "update"];
+  if (options.ignoreScripts)
+    args.push("--ignore-scripts");
+  args.push(pkg);
+  return args;
+}
+var globalBinDirCache = /* @__PURE__ */ new Map();
+var packageManagerCacheGeneration = createGenerationSource("package-manager-global-bin");
+var globalBinDirProbeFlights = createAvailabilityProbeFlight();
+async function globalBinDirsFor(pm) {
+  const cached = globalBinDirCache.get(pm);
+  if (cached)
+    return cached;
+  const generation = packageManagerCacheGeneration.capture();
+  const shared = globalBinDirProbeFlights.run(pm, () => probeGlobalBinDirs(pm, generation));
+  return shared.promise;
+}
+async function probeGlobalBinDirs(pm, generation) {
+  if (pm === "bun") {
+    const base = process.env.BUN_INSTALL || path.join(os.homedir(), ".bun");
+    const dirs2 = [path.join(base, "bin")];
+    generation.guardedWrite(pm, () => {
+      globalBinDirCache.set(pm, dirs2);
+    });
+    return dirs2;
+  }
+  const query = pm === "npm" ? ["config", "get", "prefix"] : pm === "pnpm" ? ["bin", "-g"] : ["global", "bin"];
+  const res = await safeSpawnAsync(pmBinary(pm), query, { timeout: 5e3 });
+  if (res.status !== 0 || res.error)
+    return [];
+  const out = res.stdout.trim();
+  if (!out)
+    return [];
+  const dirs = pm === "npm" ? [onWindows() ? out : path.join(out, "bin")] : [out];
+  generation.guardedWrite(pm, () => {
+    globalBinDirCache.set(pm, dirs);
+  });
+  return dirs;
+}
+async function allAvailableGlobalBinDirs(onTransient) {
+  const dirs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pm of PREFERENCE) {
+    if (!await isAvailable(pm, onTransient))
+      continue;
+    for (const dir of await globalBinDirsFor(pm)) {
+      const normalized = path.resolve(dir);
+      if (seen.has(normalized))
+        continue;
+      seen.add(normalized);
+      dirs.push(normalized);
+    }
+  }
+  return dirs;
+}
+async function findGlobalBinary(command, windowsExt = ".cmd") {
+  const candidates = onWindows() ? [`${command}${windowsExt}`, `${command}.exe`, command] : [command];
+  try {
+    for (const binDir of await allAvailableGlobalBinDirs()) {
+      for (const name of candidates) {
+        const full = path.join(binDir, name);
+        if (fs.existsSync(full))
+          return full;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+var NODE_MODULES_BIN_DIRS = [
+  path.join("node_modules", ".bin")
+];
+var VENDOR_BIN_DIRS = [path.join("vendor", "bin")];
+var VENV_BIN_DIRS = [
+  path.join(".venv", "bin"),
+  path.join("venv", "bin"),
+  path.join(".venv", "Scripts"),
+  path.join("venv", "Scripts")
+];
+function expandCandidateNames(tools, windowsExt, isWindows) {
+  return isWindows && windowsExt !== "" ? tools.flatMap((tool) => [`${tool}${windowsExt}`, tool]) : [...tools];
+}
+function* matchesInDir(dir, names, binDirs) {
+  for (const name of names) {
+    for (const binDir of binDirs) {
+      const full = path.join(dir, binDir, name);
+      if (fs.existsSync(full))
+        yield full;
+    }
+  }
+}
+function* localBinMatches(tools, startDir, options) {
+  const { windowsExt = ".cmd", homeDir = os.homedir(), binDirs = NODE_MODULES_BIN_DIRS, isWindows = onWindows(), ceiling = true } = options;
+  const names = expandCandidateNames(tools, windowsExt, isWindows);
+  for (const dir of walkUpDirs(startDir)) {
+    if (ceiling && isAtOrAboveHomeDir(dir, homeDir))
+      return;
+    yield* matchesInDir(dir, names, binDirs);
+  }
+}
+function findLocalBinUpwards(tool, startDir, options = {}) {
+  return localBinMatches([tool], startDir, options).next().value;
+}
+function findLocalBinsAt(tools, dir, options = {}) {
+  const { windowsExt = ".cmd", binDirs = NODE_MODULES_BIN_DIRS, isWindows = onWindows() } = options;
+  const names = expandCandidateNames(tools, windowsExt, isWindows);
+  return [...matchesInDir(path.resolve(dir), names, binDirs)];
+}
+function findLocalBinAt(tool, dir, options = {}) {
+  return findLocalBinsAt([tool], dir, options)[0];
+}
+async function findNodeToolBinary(tool, cwd, windowsExt = ".cmd") {
+  return findLocalBinUpwards(tool, cwd, { windowsExt }) ?? await findGlobalBinary(tool, windowsExt);
+}
+
+export {
+  _resetPackageManagerCache,
+  resolveNodePackageManager,
+  pmBinary,
+  runScriptArgs,
+  installArgs,
+  updateArgs,
+  allAvailableGlobalBinDirs,
+  findGlobalBinary,
+  VENDOR_BIN_DIRS,
+  VENV_BIN_DIRS,
+  findLocalBinUpwards,
+  findLocalBinsAt,
+  findLocalBinAt,
+  findNodeToolBinary
+};