pi-lens 4.2.1 → 4.4.0

package/dist/clients/lsp/lombok.js

@@ -1,158 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-const LOMBOK_ENV_KEYS = ["PI_LENS_LOMBOK_JAR", "LOMBOK_JAR"];
-const LOMBOK_PROJECT_FILES = [
-    "lombok.config",
-    "pom.xml",
-    "build.gradle",
-    "build.gradle.kts",
-    path.join("gradle", "libs.versions.toml"),
-];
-function fileExists(filePath) {
-    if (!filePath)
-        return false;
-    try {
-        return fs.statSync(filePath).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function readTextIfSmall(filePath, maxBytes = 512 * 1024) {
-    try {
-        const stat = fs.statSync(filePath);
-        if (!stat.isFile() || stat.size > maxBytes)
-            return "";
-        return fs.readFileSync(filePath, "utf-8");
-    }
-    catch {
-        return "";
-    }
-}
-function containsLombokDependency(text) {
-    return (/\borg\.projectlombok\b/i.test(text) ||
-        /<artifactId>\s*lombok\s*<\/artifactId>/i.test(text) ||
-        /\b(annotationProcessor|compileOnly|testCompileOnly|testAnnotationProcessor)\b[^\n]*\blombok\b/i.test(text));
-}
-export function hasLombokProject(root) {
-    const lombokConfig = path.join(root, "lombok.config");
-    if (fileExists(lombokConfig))
-        return true;
-    for (const name of LOMBOK_PROJECT_FILES) {
-        if (name === "lombok.config")
-            continue;
-        const text = readTextIfSmall(path.join(root, name));
-        if (text && containsLombokDependency(text))
-            return true;
-    }
-    return false;
-}
-function envJarCandidate(env) {
-    for (const key of LOMBOK_ENV_KEYS) {
-        const value = env[key]?.trim();
-        if (fileExists(value))
-            return path.resolve(value);
-    }
-    return undefined;
-}
-function localJarCandidates(root) {
-    return [
-        path.join(root, "lombok.jar"),
-        path.join(root, ".lombok", "lombok.jar"),
-        path.join(root, "lib", "lombok.jar"),
-        path.join(root, "libs", "lombok.jar"),
-    ];
-}
-function newestExistingJar(candidates) {
-    let best;
-    for (const candidate of candidates) {
-        try {
-            const stat = fs.statSync(candidate);
-            if (!stat.isFile())
-                continue;
-            if (!best || stat.mtimeMs > best.mtimeMs) {
-                best = { filePath: candidate, mtimeMs: stat.mtimeMs };
-            }
-        }
-        catch {
-            // missing candidate
-        }
-    }
-    return best?.filePath;
-}
-function mavenLocalLombokJar(home = os.homedir()) {
-    const base = path.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
-    let versions = [];
-    try {
-        versions = fs.readdirSync(base);
-    }
-    catch {
-        return undefined;
-    }
-    return newestExistingJar(versions.map((version) => path.join(base, version, `lombok-${version}.jar`)));
-}
-function gradleCacheLombokJar(home = os.homedir()) {
-    const base = path.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
-    const candidates = [];
-    let versions = [];
-    try {
-        versions = fs.readdirSync(base);
-    }
-    catch {
-        return undefined;
-    }
-    for (const version of versions) {
-        const versionDir = path.join(base, version);
-        let hashes = [];
-        try {
-            hashes = fs.readdirSync(versionDir);
-        }
-        catch {
-            continue;
-        }
-        for (const hash of hashes) {
-            candidates.push(path.join(versionDir, hash, `lombok-${version}.jar`));
-        }
-    }
-    return newestExistingJar(candidates);
-}
-export function resolveLombokJar(root, env = process.env) {
-    const explicit = envJarCandidate(env);
-    if (explicit)
-        return explicit;
-    return (newestExistingJar(localJarCandidates(root)) ??
-        mavenLocalLombokJar() ??
-        gradleCacheLombokJar());
-}
-export function hasLombokJavaAgent(jvmArgs) {
-    return /(^|\s)-javaagent:(?:"[^"]*lombok[^"]*\.jar"|\S*lombok\S*\.jar)/i.test(jvmArgs ?? "");
-}
-function appendJvmArg(existing, next) {
-    const trimmed = existing?.trim();
-    return trimmed ? `${trimmed} ${next}` : next;
-}
-function resolveLombokJavaAgentArg(root, baseEnv = process.env) {
-    if (baseEnv.PI_LENS_JAVA_LOMBOK === "0")
-        return undefined;
-    if (hasLombokJavaAgent(baseEnv.JDTLS_JVM_ARGS))
-        return undefined;
-    const explicitJar = envJarCandidate(baseEnv);
-    if (!explicitJar && !hasLombokProject(root))
-        return undefined;
-    const jar = explicitJar ?? resolveLombokJar(root, baseEnv);
-    return jar ? `-javaagent:${jar}` : undefined;
-}
-export function createLombokJdtlsArgs(root, baseEnv = process.env) {
-    const javaAgent = resolveLombokJavaAgentArg(root, baseEnv);
-    return javaAgent ? [`--jvm-arg=${javaAgent}`] : [];
-}
-export function createLombokJdtlsEnv(root, baseEnv = process.env) {
-    const javaAgent = resolveLombokJavaAgentArg(root, baseEnv);
-    if (!javaAgent)
-        return undefined;
-    return {
-        ...baseEnv,
-        JDTLS_JVM_ARGS: appendJvmArg(baseEnv.JDTLS_JVM_ARGS, javaAgent),
-    };
-}

package/dist/clients/lsp/path-utils.js

@@ -1,5 +0,0 @@
-/**
- * Re-export from shared path-utils.
- * Kept as a local module for LSP imports that use relative paths.
- */
-export { isUnderDir, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, uriToDiskPath, uriToPath, } from "../path-utils.js";

package/dist/clients/lsp/pending-aux-coverage.js

@@ -1,251 +0,0 @@
-/**
- * #2001/#2002 — collect-later coverage store for slow auxiliary LSP servers.
- *
- * When a `with-auxiliary` touch's aux-grace window expires without a
- * publication from an auxiliary scanner (opengrep on Windows measures ~8s per
- * scan against a 2s grace), that scanner's eventual findings were silently
- * cached inside its LSP client and never surfaced to the agent: the auxiliary
- * contributed ZERO agent-visible coverage on most edits.
- *
- * This module is the bounded hand-off between the two halves of the fix:
- *
- *   - PRODUCER (`clients/lsp/index.ts`'s aux-grace wait): after the outcomes
- *     are decided, every auxiliary with no publication evidence for this
- *     content (`cut_off` or `silent`, minus #1493's published-this-content
- *     exemption) marks its (filePath, serverId) pair here. DEFERRED servers
- *     are never marked — they never received the content, so their cache
- *     still describes the PREVIOUS revision (#1459).
- *   - CONSUMER (`clients/runtime-turn.ts` at turn_end): drains the store,
- *     probes each pair through the read-only
- *     `LSPService.readCachedDiagnosticsForServers` seam, freshness-gates the
- *     result against `markedAtMs`, and delivers survivors as the registered
- *     `runtime-turn:late-auxiliary-findings` gated surface. A pair whose
- *     client is alive but has STILL published nothing is re-armed until
- *     readLateAuxRearmTtlMs() (env-overridable via
- *     `PI_LENS_LATE_AUX_REARM_TTL_MS`) after the LAST re-arm, so a scan
- *     finishing between two turn ends is not lost and a demonstrably alive
- *     but slow scanner keeps its window open; `markedAtMs` itself never
- *     moves — it stays the immutable freshness baseline the delivery gate
- *     stats against. Past the TTL, or when the client is gone, the entry is
- *     dropped silently (best-effort by design).
- *
- * Bounds: at most MAX_PENDING_ENTRIES (file, server) pairs, insertion-order
- * eviction of the OLDEST pair when the cap is exceeded (shape 9 discipline —
- * the axis that grows is the pair count, so that is the axis that is capped).
- * Keys fold through `normalizeEphemeralMapKey`: this is a hot single-process
- * index whose keys are produced by this same process's touch path, so the
- * cheap ephemeral normalizer is the lifetime-appropriate choice per the
- * PathKeyedMap guidance — no realpath walk on the per-edit path.
- *
- * #2324 F3/R2-A: this module ALSO hands off in the other direction, for
- * ast-grep specifically. Gate B's napi runner is a second producer of
- * coverage for the same (file, "ast-grep") pair — when it runs as the
- * fallback and actually evaluates rules, it calls
- * {@link recordNapiFallbackCoverage}. The PRODUCER above reads that record
- * (via {@link napiFallbackCoveredSince}) before deciding whether to mark a
- * pair, because napi's Gate-B check settles synchronously while the aux-grace
- * wait's own decision takes up to its full grace budget — by the time the
- * wait is ready to mark, THIS touch's napi run (if any) has already finished,
- * so the wait can reliably see it; a clear issued from napi's side cannot,
- * because the mark it would be racing has not been written yet.
- * {@link clearPendingAuxiliaryCoverage} is still used, but only to drop a
- * LEFTOVER pair from an EARLIER touch once napi has fresh evaluated findings
- * to supersede it.
- */
-import { BoundedFifoMap } from "../bounded-cache.js";
-import { normalizeEphemeralMapKey } from "../path-utils.js";
-/** Maximum pending (filePath, serverId) pairs; oldest evicted beyond this. */
-export const MAX_PENDING_AUX_ENTRIES = 50;
-/**
- * Default for how long a marked pair keeps being re-probed at successive
- * turn ends when the client is alive but has published nothing yet. Covers
- * opengrep's measured ~8s worst case many times over without pinning state
- * forever. Overridable via `PI_LENS_LATE_AUX_REARM_TTL_MS`.
- */
-export const DEFAULT_LATE_AUX_REARM_TTL_MS = 5 * 60_000;
-export const MAX_LATE_AUX_REARMS = 8;
-/**
- * Read the `PI_LENS_LATE_AUX_REARM_TTL_MS` env override at call time (not
- * module load time) so tests and users can tune without a rebuild — same
- * shape as `readEnvAuxGraceMs` in clients/lsp/index.ts. Absent, non-numeric,
- * or negative values fall back to {@link DEFAULT_LATE_AUX_REARM_TTL_MS}.
- */
-export function readLateAuxRearmTtlMs() {
-    const raw = process.env.PI_LENS_LATE_AUX_REARM_TTL_MS;
-    if (raw === undefined)
-        return DEFAULT_LATE_AUX_REARM_TTL_MS;
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed) || parsed < 0)
-        return DEFAULT_LATE_AUX_REARM_TTL_MS;
-    return parsed;
-}
-/**
- * Whether a pending pair is past its re-arm TTL and should be retired at the
- * next drain. The TTL anchors on {@link PendingAuxCoverageEntry.lastRearmedAtMs}
- * when present (each successful probe extends the window), else on
- * `markedAtMs`. `nowMs` is injectable so tests are deterministic.
- */
-export function isPendingAuxiliaryPastRearmTtl(pair, nowMs = Date.now()) {
-    const anchor = pair.lastRearmedAtMs ?? pair.markedAtMs;
-    return nowMs - anchor >= readLateAuxRearmTtlMs();
-}
-const pending = new BoundedFifoMap(MAX_PENDING_AUX_ENTRIES);
-/**
- * #2168: pairs evicted at the cap have no other retirement record — the
- * drain-time reconciliation in `runtime-turn.ts` never sees them because
- * they are gone before a drain can observe them. Counted here so the
- * consumer can fold them into its per-turn `pairCreated`/retirement sum
- * instead of the pair vanishing uncounted.
- */
-let capEvictedCount = 0;
-function pairKey(filePath, serverId) {
-    return `${normalizeEphemeralMapKey(filePath)}\u0000${serverId}`;
-}
-/**
- * Mark (or re-arm) one file's pending auxiliary coverage for `serverIds`.
- * An existing pair keeps its ORIGINAL `markedAtMs`; only genuinely new pairs
- * stamp the current time. Insertion order updates on re-mark so a re-armed
- * pair is not the next one evicted at the cap.
- *
- * `rearmedAtMs` is the turn-end consumer's re-arm form: it stamps
- * `lastRearmedAtMs` (the TTL anchor) WITHOUT moving the freshness baseline,
- * so each successful probe extends the wait window while the delivery gate
- * keeps comparing mtimes against the original mark. The producer form (no
- * `rearmedAtMs`) marks a NEWER revision, so it resets any prior re-arm stamp
- * along with the baseline — the new pair's TTL starts from its own mark.
- */
-export function markPendingAuxiliaryCoverage(filePath, serverIds, markedAtMs = Date.now(), rearmedAtMs, rearmCount) {
-    for (const serverId of serverIds) {
-        const key = pairKey(filePath, serverId);
-        const existing = pending.get(key);
-        if (existing) {
-            // #2027 review: bump the freshness baseline on producer re-mark. A
-            // newer touch means the auxiliary is scanning a NEWER revision;
-            // keeping the original baseline would make every post-baseline mtime
-            // read as stale, permanently dropping current-revision findings.
-            // A re-arm form never moves the baseline — only the TTL anchor.
-            pending.delete(key);
-            pending.set(key, rearmedAtMs === undefined
-                ? { filePath, serverId, markedAtMs }
-                : {
-                    filePath,
-                    serverId,
-                    markedAtMs: existing.markedAtMs,
-                    lastRearmedAtMs: rearmedAtMs,
-                    rearmCount: rearmCount ?? (existing.rearmCount ?? 0) + 1,
-                });
-            continue;
-        }
-        const evicted = pending.set(key, rearmedAtMs === undefined
-            ? { filePath, serverId, markedAtMs }
-            : {
-                filePath,
-                serverId,
-                markedAtMs,
-                lastRearmedAtMs: rearmedAtMs,
-                rearmCount: rearmCount ?? 1,
-            });
-        capEvictedCount += evicted.length;
-    }
-}
-/** Re-arm a drained pair while carrying its ceiling count across the drain. */
-export function rearmPendingAuxiliaryCoverage(pair, rearmedAtMs = Date.now(), refreshBaseline = false) {
-    const nextCount = (pair.rearmCount ?? 0) + 1;
-    markPendingAuxiliaryCoverage(pair.filePath, [pair.serverId], refreshBaseline ? rearmedAtMs : pair.markedAtMs, rearmedAtMs, nextCount);
-}
-/**
- * Read-only check: is this (file, server) pair currently pending late
- * delivery? #2324 F2: Gate B's "has this server EVER published for this
- * file" answer goes stale the moment a later touch's aux-grace wait finds
- * the server silent for the CURRENT content — a pending pair is exactly
- * that signal, so a caller deciding whether to skip a fallback runner can
- * tell "published, still current" from "published once, silent now" without
- * draining or mutating the store.
- */
-export function hasPendingAuxiliaryCoverage(filePath, serverId) {
-    return pending.has(pairKey(filePath, serverId));
-}
-/**
- * Remove one pair after its findings were delivered, or whenever the caller
- * knows it is resolved. Unknown pairs are a no-op.
- */
-export function clearPendingAuxiliaryCoverage(filePath, serverId) {
-    pending.delete(pairKey(filePath, serverId));
-}
-/**
- * Drain ALL pending pairs (removing them from the store) and return them in
- * insertion order. The consumer re-arms the still-waiting subset via
- * {@link markPendingAuxiliaryCoverage}'s `rearmedAtMs` form, which preserves
- * each entry's original `markedAtMs` and stamps `lastRearmedAtMs`.
- */
-export function drainPendingAuxiliaryCoverage() {
-    const drained = [...pending.values()];
-    pending.clear();
-    return drained;
-}
-/** Current pending pair count for bounded reconciliation telemetry. */
-export function pendingAuxiliaryCoverageSize() {
-    return pending.size;
-}
-/**
- * Drain (read and reset) the cap-eviction count accumulated since the last
- * drain. Mirrors {@link drainPendingAuxiliaryCoverage}'s consume-once shape
- * so the turn-end consumer can fold evictions that happened between two
- * turn ends into its reconciliation sum exactly once, never accumulating
- * across turns.
- */
-export function drainPendingAuxCapEvictedCount() {
-    const count = capEvictedCount;
-    capEvictedCount = 0;
-    return count;
-}
-/**
- * #2324 R2-A: (file) -> the timestamp of the LAST time the ast-grep napi
- * fallback actually evaluated rules for it, as Gate B's runner
- * (`clients/dispatch/runners/ast-grep-napi.ts`). This is the cross-module
- * hand-off the aux-grace wait (`clients/lsp/index.ts`) needs to avoid
- * marking a pending late-auxiliary pair for a file napi ALREADY delivered
- * for on THIS touch.
- *
- * Ordering is why a synchronous clear-on-napi-run cannot do this job: the
- * wait that decides whether to mark a pair runs for up to ~1800ms (its own
- * grace budget) AFTER napi's Gate-B check, which is a single map lookup.
- * Clearing at napi's run start (or end) races the mark and reliably loses —
- * the mark, if any, has not been written yet. The wait itself is the only
- * place that knows the outcome, so it is the one that must consult this
- * store and skip marking, not the runner that must guess at the wait's
- * future decision.
- *
- * Bounded like the pending-pair store itself; oldest evicted first.
- */
-export const MAX_NAPI_COVERAGE_ENTRIES = 50;
-const napiFallbackCoverage = new BoundedFifoMap(MAX_NAPI_COVERAGE_ENTRIES);
-/** Record that napi actually evaluated rules for `filePath` at `atMs`. */
-export function recordNapiFallbackCoverage(filePath, atMs = Date.now()) {
-    const key = normalizeEphemeralMapKey(filePath);
-    napiFallbackCoverage.delete(key);
-    napiFallbackCoverage.set(key, atMs);
-}
-/**
- * Did napi cover `filePath` at or after `sinceMs`? The aux-grace wait passes
- * its own `waitStartedAt` baseline so a STALE coverage record from an
- * earlier touch (napi ran for a PREVIOUS revision) cannot suppress marking a
- * pair this touch's silent server genuinely needs delivered later.
- */
-export function napiFallbackCoveredSince(filePath, sinceMs) {
-    const ts = napiFallbackCoverage.get(normalizeEphemeralMapKey(filePath));
-    return ts !== undefined && ts >= sinceMs;
-}
-/** Test-only reset for the napi-coverage hand-off. */
-export function resetNapiFallbackCoverageForTests() {
-    napiFallbackCoverage.clear();
-}
-/**
- * Session-boundary clear (#1635): pending baselines are unreachable after
- * reset (the generation-stamped keys no longer match any active session).
- */
-export function resetPendingAuxiliaryCoverage() {
-    pending.clear();
-    capEvictedCount = 0;
-    napiFallbackCoverage.clear();
-}

package/dist/clients/lsp/position-encoding.js

@@ -1,61 +0,0 @@
-/**
- * LSP position-encoding negotiation (#269).
- *
- * LSP positions are `(line, character)` where `character` is an offset into the
- * line measured in code units of the negotiated `positionEncoding`. The pre-3.17
- * default — and what callers hand us — is UTF-16. LSP 3.17 lets a server pick a
- * different encoding via `ServerCapabilities.positionEncoding`; some servers
- * (rust-analyzer ≥ 2024, recent gopls) prefer UTF-8. If we keep sending UTF-16
- * offsets to a UTF-8 server, every `character` past a multibyte glyph on the
- * line is wrong, and navigation silently lands on the wrong column.
- *
- * This module is the pure core: pick the encoding from the server's reply, and
- * translate a UTF-16 character offset to the negotiated encoding using the
- * line's text. UTF-16 is the identity (and the hot path — no work, no I/O).
- */
-/** Encodings we advertise to servers, in preference order (UTF-16 first to keep
- *  the historical default unless a server explicitly wants otherwise). */
-export const ADVERTISED_POSITION_ENCODINGS = [
-    "utf-16",
-    "utf-8",
-];
-/**
- * The encoding the server will use, read from its initialize reply. Defaults to
- * UTF-16 when the server doesn't advertise one (pre-3.17 behaviour). An
- * unrecognised value also falls back to UTF-16 — safer than guessing.
- */
-export function negotiatePositionEncoding(serverCapabilities) {
-    const raw = serverCapabilities?.positionEncoding;
-    if (raw === "utf-8" || raw === "utf-16" || raw === "utf-32")
-        return raw;
-    return "utf-16";
-}
-/**
- * Convert a UTF-16 character offset within `lineText` to the negotiated
- * encoding's offset. UTF-16 is the identity. UTF-8 counts bytes; UTF-32 counts
- * Unicode code points. An offset past the end of the line is clamped to the
- * line length (in the source UTF-16 units) before conversion.
- */
-export function convertCharacterOffset(encoding, lineText, utf16Character) {
-    if (encoding === "utf-16")
-        return utf16Character;
-    if (utf16Character <= 0)
-        return 0;
-    // Slice in UTF-16 units (JS string semantics), then re-measure the prefix in
-    // the target encoding's units.
-    const clamped = Math.min(utf16Character, lineText.length);
-    const prefix = lineText.slice(0, clamped);
-    if (encoding === "utf-8")
-        return Buffer.byteLength(prefix, "utf8");
-    // utf-32: number of Unicode code points (spread iterates by code point).
-    return [...prefix].length;
-}
-/** Extract the text of a single 0-based line from full file content. */
-export function lineTextAt(content, line) {
-    if (line < 0)
-        return "";
-    // Split on \n; trailing \r is irrelevant to offset math (it's after the
-    // character columns the caller cares about, and never multibyte).
-    const lines = content.split("\n");
-    return lines[line] ?? "";
-}

package/dist/clients/lsp/ruby-drive-dirs.js

@@ -1,83 +0,0 @@
-/**
- * Windows Ruby-installer drive-root version-dir discovery (refs #1137).
- *
- * The Ruby installer drops versioned directories (e.g. `Ruby34-x64`) directly
- * at a drive root, and the drive and version suffix vary — so both the LSP
- * candidate builder (`rubyBinCandidates`) and the spawn PATH augmenter
- * (`buildAugmentedPath`) scan the drive root for `ruby<N>...` directories.
- *
- * Enumerating a drive root **synchronously on every LSP spawn** was a genuine
- * #1137 event-loop offender: a stalled cloud/network-backed drive-root
- * `readdirSync` blocks the Node loop (and pi's TUI) for the entire stall. This
- * module makes that enumeration:
- *   1. **O(1) amortized** — the matching directory names are memoized for the
- *      process (the set is static for a session; the previous inline code
- *      equally required a restart to notice a new Ruby install on PATH), and
- *   2. **non-blocking on the hot path** — `buildAugmentedPath` (called on every
- *      spawn) reads the drive root via `fs.promises.readdir` off the loop.
- *
- * Both readers share ONE cache keyed by `driveRoot`, so at most one drive-root
- * read happens per drive per process regardless of which reader runs first.
- * Callers derive their own paths from the returned directory NAMES (the two
- * readers build different suffixes: `bin/<tool>` vs `bin`), so only the raw
- * `ruby<N>` names are cached.
- */
-import { BoundedLruCache } from "../bounded-cache.js";
-import { normalizeMapKey } from "../path-utils.js";
-import * as fs from "node:fs";
-/** Matches the Ruby installer's `Ruby34-x64`, `ruby3.3`, … drive-root dirs. */
-const RUBY_VERSION_DIR = /^ruby\d/i;
-/** Process-lifetime memo of matching dir names, keyed by drive root (e.g. `C:\`). */
-const rubyDirNamesCache = new BoundedLruCache(16);
-function rubyDriveKey(driveRoot) {
-    return normalizeMapKey(driveRoot);
-}
-function filterRubyDirNames(entries) {
-    return entries.filter((name) => RUBY_VERSION_DIR.test(name));
-}
-/**
- * Memoized **synchronous** enumeration for sync callers (`rubyBinCandidates`).
- * First call reads the drive root once (fail-open to `[]` on an unreadable
- * root); every later call is a cache hit. If an async caller populated the
- * cache first, this returns that result with no drive-root read at all.
- */
-export function getRubyVersionDirNamesSync(driveRoot) {
-    const key = rubyDriveKey(driveRoot);
-    const cached = rubyDirNamesCache.get(key);
-    if (cached !== undefined)
-        return cached;
-    let names;
-    try {
-        names = filterRubyDirNames(fs.readdirSync(driveRoot));
-    }
-    catch {
-        names = [];
-    }
-    rubyDirNamesCache.set(key, names);
-    return names;
-}
-/**
- * Memoized **async** twin for the hot spawn path (`buildAugmentedPath`) — reads
- * the drive root via `fs.promises.readdir` so a slow/stalled cloud-backed drive
- * root never blocks the event loop. Shares the same process cache as the sync
- * reader (identical content, so a benign sync/async populate race is fine).
- */
-export async function getRubyVersionDirNamesAsync(driveRoot) {
-    const key = rubyDriveKey(driveRoot);
-    const cached = rubyDirNamesCache.get(key);
-    if (cached !== undefined)
-        return cached;
-    let names;
-    try {
-        names = filterRubyDirNames(await fs.promises.readdir(driveRoot));
-    }
-    catch {
-        names = [];
-    }
-    rubyDirNamesCache.set(key, names);
-    return names;
-}
-/** Test-only: clear the process memo so each case starts cold. */
-export function __resetRubyDriveDirsCacheForTest() {
-    rubyDirNamesCache.clear();
-}