@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/lsp/session-roots.js

@@ -1,192 +0,0 @@
-/**
- * The session-root registry: which project roots does this process serve?
- *
- * #2052. A file is IN-SESSION when it lies within any initialized session cwd.
- * `initLSPConfig` (`clients/lsp/config.ts`) is the single writer, and every
- * entry point funnels through it — `ensureLSPConfigInitialized` (`index.ts`),
- * `ensureReady` (`mcp/server.ts`), `clients/runtime-session.ts`, and
- * `clients/lens-engine.ts` — so registration needs no second call site.
- *
- * WHY THIS IS ITS OWN MODULE, not a helper inside `config.ts`: `clients/lsp/
- * index.ts`'s import surface from `config.js` is mirrored by an explicit
- * `vi.mock` factory in ~58 test files. Importing a new symbol from `config.js`
- * breaks every one of them with "No export is defined on the mock", which is a
- * standing tax on any future export.
- *
- * WHY THE CONFIG PAYLOAD LIVES HERE TOO (#2518). Until this fix the payload
- * lived in `config.ts`'s own 32-entry `workspaceConfigs` LRU while this
- * registry held 128, and the two answered halves of ONE question: the registry
- * decides whether a root still needs initializing (`ensureReady`,
- * `mcp/server.ts`), the payload decides whether the operator's
- * `lsp.disabledServers` denial applies (`isServerDisabled`). Thirty-three
- * `ensureReady` calls on other cwds therefore dropped a LIVE root's denial
- * while the registry still reported the root ready, so nothing re-initialized
- * it and a server the operator had turned off came back — #2415 AC 3's exact
- * prohibition, silently.
- *
- * Tying the two CAPS would not have fixed it. `initLSPConfig` registers the
- * root BEFORE its `await` and writes the payload AFTER, so two interleaved
- * initializations enter the two containers in different orders; with separate
- * containers the same cap still evicts different keys from each. One entry per
- * root — the key IS the registration, the value IS the payload — makes a
- * payload miss for a served root impossible by construction instead of by an
- * ordering agreement between two modules.
- *
- * WHY IT IS NOT A LATCH. The first attempt at #2052 used a single
- * last-writer-wins session cwd that fell back to `process.cwd()`. Two bugs
- * followed directly from that shape, and this module's contract excludes both:
- *
- *  - MULTI-ROOT. A process that initializes projA and then projB serves BOTH.
- *    A latch silently made projA's files foreign the moment projB registered.
- *  - FAIL-OPEN ON EMPTY. An empty registry declines NOTHING. Declining is a
- *    hard refusal to answer, so it must rest on positive evidence that a
- *    session exists AND that the file sits outside it — never on the absence
- *    of evidence. Callers that never declared a session (isolated tests, API
- *    consumers, a request racing initialization) therefore keep the pre-#2052
- *    clamp behavior instead of having `process.cwd()` gate a refusal.
- *
- * This is also the seam #2053 needs: an explicit `analysisRoot` registers here.
- */
-import { BoundedFifoMap } from "../bounded-cache.js";
-import { incrementDegradationCount } from "../degradation-ledger.js";
-import { isSameOrWithin } from "./server.js";
-import path from "node:path";
-/**
- * Insertion-ordered, so eviction drops the OLDEST root. `BoundedFifoMap`
- * (#2442) owns the eviction; this module no longer hand-rolls it. FIFO and not
- * LRU on purpose: eviction order is REGISTRATION order, so a config write for
- * an already-registered root cannot reorder the registry underneath the
- * `ensureReady` memo that reads it.
- *
- * The value is `undefined` between `registerSessionRoot` and the config write
- * that follows the loader's `await` — the same window in which, before #2518,
- * no payload existed for the root at all. {@link sessionRootConfigEntries}
- * skips those entries, so an in-flight root resolves exactly as it did before:
- * to a shorter ancestor root's config, or to none.
- */
-const SESSION_ROOT_CAP = 128;
-const sessionRoots = new BoundedFifoMap(SESSION_ROOT_CAP);
-/**
- * The cap dropped a root this process was serving. Its files fall back to
- * pre-#2052 clamp behavior and its `lsp.disabledServers` denial stops applying
- * until something initializes the root again — which `shouldInitializeSessionRoot`
- * now guarantees the next SESSION START OR TOOL CALL naming that root does,
- * because the registration went with the payload. Nothing else re-initializes:
- * the readers of the denial (`isServerDisabled`, `getServersForFileWithConfig`,
- * `getServerInitOverride`) ask the store, they never load it.
- *
- * A CONSTANT subject, counted rather than latched (#2518 review F3). The
- * subject cannot be the evicted root: the ledger's `recordDegradationOnce` /
- * `incrementDegradationCount` dedupe keys are unbounded, so a per-root subject
- * would grow one key per root a long-lived process ever cycles through — a
- * container bounded on one axis and unbounded on another, which is the shape
- * this whole fix is about. That argument bounds the SUBJECT; it is not an
- * argument for throwing the tally away, and the number of roots this process
- * has had to drop is exactly what an operator tunes the cap against. The
- * ledger keeps one entry per kind/subject and emits durable rows only on
- * power-of-two counts, so counting is as bounded here as latching.
- *
- * Returns the evicted roots so the caller can drop the per-root session
- * bookkeeping that described them — `initLSPConfig` releases each one's
- * `config_resolved` claim (review F1).
- */
-function noteEvictedRoots(evicted) {
-    const roots = evicted.map(([root]) => root);
-    if (roots.length > 0) {
-        incrementDegradationCount({
-            kind: "lsp-session-root-evicted",
-            subject: `cap=${SESSION_ROOT_CAP}`,
-            reason: `session root registry at capacity; dropped ${roots[0]} and will load it again on the next session start or tool call naming that root`,
-        });
-    }
-    return roots;
-}
-/**
- * Record a session cwd as served. Idempotent; re-registering refreshes nothing.
- * Returns the roots this insertion dropped at the cap, oldest first.
- */
-export function registerSessionRoot(cwd) {
-    const root = path.resolve(cwd);
-    // Present already: leave the entry alone. Writing the `undefined`
-    // placeholder over a loaded config would blank a served root's denial for
-    // the length of the re-initializing load — the #2518 window in miniature.
-    if (sessionRoots.has(root))
-        return [];
-    return noteEvictedRoots(sessionRoots.set(root, undefined));
-}
-/**
- * Store the config `initLSPConfig` just loaded for a root it registered.
- *
- * Re-inserts the root when the cap dropped it while the load was in flight:
- * the caller is a live session declaring this root right now, so the pair
- * belongs in the registry — and it is a PAIR, which is what keeps the payload
- * from outliving the registration or the registration from outliving the
- * payload.
- *
- * Returns the roots this write dropped at the cap, oldest first.
- */
-export function setSessionRootConfig(cwd, config) {
-    return noteEvictedRoots(sessionRoots.set(path.resolve(cwd), config));
-}
-/**
- * Every served root that has a loaded config, in registration order —
- * `getConfigForFile`'s (`config.ts`) longest-prefix walk. Entries still
- * awaiting their first load are skipped; see the store's doc comment.
- */
-export function sessionRootConfigEntries() {
-    return sessionRoots;
-}
-/** Return whether this exact root is still served after cap eviction. */
-export function isSessionRootRegistered(cwd) {
-    return sessionRoots.has(path.resolve(cwd));
-}
-/**
- * True when a readiness memo must run initialization for this root.
- *
- * The memo alone is never enough (#2052 R1, #2518): a readiness set caps
- * itself, and `initLSPConfig` has callers (`clients/runtime-session.ts`,
- * `clients/lens-engine.ts`) that no memo sees, so a memo hit can outlive the
- * registration — and with it the config that carries the operator's denial.
- * Every readiness memo asks this function, never its own `has` alone.
- */
-export function shouldInitializeSessionRoot(cwd, readyRoots) {
-    const normalized = path.resolve(cwd);
-    return !readyRoots.has(normalized) || !isSessionRootRegistered(normalized);
-}
-/**
- * Is `filePath` outside EVERY registered session root?
- *
- * Returns false (serve it) when the registry is empty — see the fail-open rule
- * in this module's header. Containment uses `isSameOrWithin`, the same
- * comparator the LSP root ceiling uses, which selects `path.win32` by path
- * SHAPE rather than by `process.platform` (shape 2 / #1150).
- */
-export function isOutsideAllSessionRoots(filePath) {
-    if (sessionRoots.size === 0)
-        return false;
-    const resolved = path.resolve(filePath);
-    for (const root of sessionRoots.keys()) {
-        if (isSameOrWithin(root, resolved))
-            return false;
-    }
-    return true;
-}
-/**
- * The registered roots, for the decline telemetry record. Sorted with a
- * code-unit comparator so the emitted string is deterministic across locales
- * (#1883), and capped because the record is BOUNDED — a process with many
- * roots must not emit an unbounded path list.
- */
-export function getSessionRootsForTelemetry(limit = 4) {
-    return [...sessionRoots.keys()]
-        .sort((a, b) => Number(a > b) - Number(a < b))
-        .slice(0, limit);
-}
-/**
- * Clear the registry — the roots AND the configs they carry, which are one
- * store since #2518, so a reset cannot leave the two disagreeing about which
- * roots exist. Called by `resetLSPConfigStateForTests`.
- */
-export function resetSessionRootsForTests() {
-    sessionRoots.clear();
-}

package/node_modules/pi-lens/dist/clients/lsp/spawn-history.js

@@ -1,17 +0,0 @@
-/** Process-lifetime history of successful LSP spawn plus initialize durations. */
-import { BoundedFifoMap } from "../bounded-cache.js";
-const MAX_SERVER_HISTORIES = 64;
-const successfulSpawnDurationMs = new BoundedFifoMap(MAX_SERVER_HISTORIES);
-export function recordSuccessfulLspSpawn(serverId, durationMs) {
-    if (!Number.isFinite(durationMs) || durationMs < 0)
-        return;
-    successfulSpawnDurationMs.delete(serverId);
-    successfulSpawnDurationMs.set(serverId, durationMs);
-}
-export function getSuccessfulLspSpawnDurationMs(serverId) {
-    return successfulSpawnDurationMs.get(serverId);
-}
-/** Test-only: isolate process-lifetime history between cases. */
-export function _clearSuccessfulLspSpawnHistoryForTests() {
-    successfulSpawnDurationMs.clear();
-}

package/node_modules/pi-lens/dist/clients/lsp/sync-kind.js

@@ -1,56 +0,0 @@
-/**
- * LSP `textDocument/didChange` sync-kind negotiation (#1669).
- *
- * A server advertises how it wants document changes described via
- * `ServerCapabilities.textDocumentSync`, either as a bare
- * `TextDocumentSyncKind` number (the legacy pre-3.0 shape) or as a
- * `TextDocumentSyncOptions` object whose `change` field carries the kind.
- * pi-lens always sent a single whole-document `{ text }` change event — valid
- * for `Full` (1) and harmless for `None` (0, since the server ignores content
- * changes entirely), but out of spec for `Incremental` (2): an
- * Incremental-only server expects every change event to carry a `range`.
- *
- * This module is the pure negotiation core, mirroring `position-encoding.ts`'s
- * shape: read the kind from the server's `initialize` reply, defaulting to
- * `Full` when the server doesn't advertise one — the same shape pi-lens has
- * always sent, so an unrecognized/absent value never regresses `Full`/`None`
- * behavior.
- */
-export const TEXT_DOCUMENT_SYNC_KIND_FULL = 1;
-export const TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL = 2;
-function isSyncKind(value) {
-    return value === 0 || value === 1 || value === 2;
-}
-/**
- * The `change` sync kind the server negotiated, read from its `initialize`
- * reply. Defaults to `Full` (pi-lens's historical always-whole-document
- * behavior) when the server omits `textDocumentSync` entirely, or advertises
- * a shape/value this function doesn't recognize.
- */
-export function negotiateSyncKind(serverCapabilities) {
-    const sync = serverCapabilities?.textDocumentSync;
-    // Legacy shape: the whole field IS the kind.
-    if (isSyncKind(sync))
-        return sync;
-    // 3.0+ shape: `TextDocumentSyncOptions.change`.
-    if (sync && typeof sync === "object") {
-        const change = sync.change;
-        if (isSyncKind(change))
-            return change;
-    }
-    return TEXT_DOCUMENT_SYNC_KIND_FULL;
-}
-export function negotiateSaveOptions(serverCapabilities) {
-    const sync = serverCapabilities?.textDocumentSync;
-    if (!sync || typeof sync !== "object")
-        return undefined;
-    const save = sync.save;
-    if (save === true)
-        return { includeText: false };
-    if (save && typeof save === "object") {
-        return {
-            includeText: save.includeText === true,
-        };
-    }
-    return undefined;
-}

package/node_modules/pi-lens/dist/clients/lsp/tsserver-sync.js

@@ -1,332 +0,0 @@
-/**
- * #611/#707: classic typescript-language-server tsserver sync diagnostic
- * commands — shared between the `lsp_diagnostics` tool (where the escape hatch
- * was first introduced in #611) and the per-edit `touchFile` dispatch path
- * (wired in #707 to avoid burning the full wait budget on clean TS files).
- *
- * These are a genuine synchronous request/response tsserver protocol extension
- * exposed via `workspace/executeCommand` with command
- * `typescript.tsserverRequest`. Unlike the push-only LSP surface, calling them
- * gives a definitive answer: empty array = confirmed clean, non-empty = real
- * diagnostics the server had computed but never published on the push surface.
- *
- * Empirically verified live (2026-07, typescript-language-server 5.9.3, this
- * repo's own tsconfig.json as the fixture project):
- *
- *   workspace/executeCommand {
- *     command: "typescript.tsserverRequest",
- *     arguments: [
- *       "semanticDiagnosticsSync" | "syntacticDiagnosticsSync",
- *       { file: "<absolute path>", includeLinePosition: true }
- *     ]
- *   }
- *
- * resolves { executed: true, result: { seq, type: "response", command,
- * request_seq, success, body: [...] } }, where each body entry is tsserver's
- * NATIVE protocol diagnostic shape — `message`, `category`
- * ("error"|"warning"|"suggestion"), `code`, `startLocation`/`endLocation` as
- * `{ line, offset }` — NOT the LSP `Diagnostic` shape, and both `line`/`offset`
- * are 1-based (LSP is 0-based).
- *
- * All helpers here are pure-function and never throw (every error path returns
- * `undefined`). The caller must handle `undefined` as "sync path unavailable,
- * fall back to existing unconfirmed/timed-out behavior".
- */
-import { logLatency } from "../latency-logger.js";
-import { normalizeMapKey } from "../path-utils.js";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
-/**
- * tsserver's synthetic inferred-project name, as its own source builds it:
- * `"/dev/null/inferredProject" + counter + "*"`. `/dev/null` is a deliberate
- * sentinel prefix — no real config file can live there — and matching the WHOLE
- * string against it is the only safe test.
- *
- * #1645 review F4: an earlier version also matched an UNANCHORED
- * `/inferred[-_ ]?project/i` anywhere in the string. That inverted the verdict
- * for a real project in a directory a human happened to name that way —
- * `/repo/inferred-project/tsconfig.json` classified as INFERRED, which demoted
- * its genuine blocking errors. A classifier that gates authority must never key
- * off user-controlled directory names.
- *
- * The optional drive-letter/backslash arm covers a host that normalizes the
- * sentinel through win32 path handling before it reaches us; the `/dev/null`
- * prefix is still required.
- */
-const INFERRED_PROJECT_SENTINEL = /^(?:[A-Za-z]:)?[/\\]dev[/\\]null[/\\]inferredProject\d*\*?$/i;
-/**
- * Classify one tsserver `projectInfo` response body.
- *
- * `configFileName` is tsserver's own answer to "which project owns this file".
- * A real project answers with a `tsconfig.json`/`jsconfig.json` path; a file
- * that matches no project's `include`/`files` lands in tsserver's synthetic
- * inferred project, whose `configFileName` is a `/dev/null/inferredProject1*`
- * placeholder. The two are the same field, so the placeholder shape is the only
- * thing that separates "checked against the project's real compiler options"
- * from "checked against defaults nobody configured" (#1640).
- *
- * Exported so the diagnostic-demotion seam (`inferred-project.ts`) and the
- * #1412 telemetry probe share ONE classifier — a second hand-rolled
- * configFileName test would be a parallel source of truth for the same verdict.
- */
-export function classifyProjectInfo(body) {
-    if (!body || typeof body !== "object") {
-        return { projectKind: "unassociated", association: "unassociated" };
-    }
-    const info = body;
-    const configFile = typeof info.configFileName === "string" && info.configFileName.length > 0
-        ? info.configFileName
-        : undefined;
-    const inferred = configFile
-        ? INFERRED_PROJECT_SENTINEL.test(configFile)
-        : false;
-    const projectKind = configFile
-        ? inferred
-            ? "inferred"
-            : /(?:^|[/\\])(?:tsconfig|jsconfig)\.json$/i.test(configFile)
-                ? "configured"
-                : "unassociated"
-        : "unassociated";
-    return {
-        projectKind,
-        ...(configFile ? { configFile } : {}),
-        association: info.languageServiceDisabled === true
-            ? "language-service-disabled"
-            : projectKind === "unassociated"
-                ? "unassociated"
-                : "associated",
-    };
-}
-/**
- * #1412: after classic TypeScript's first successful didOpen, sample the
- * tsserver project association without delaying diagnostics. The supplied
- * executeCommand channel owns the existing bounded anti-deadlock backstop.
- */
-export async function probeTsserverProjectIdentity(options) {
-    const normalizedFile = options.normalizedFile ?? normalizeMapKey(options.file);
-    const startedAt = Date.now();
-    // Logging starts only once a probe is actually eligible and attempted:
-    // ineligible servers (wrong serverId/launchVariant, no command channel) and
-    // already-probed dedupe are both routine, high-volume, and per-server — a
-    // bare return keeps them out of the telemetry stream entirely instead of
-    // writing an `lsp_typescript_project_identity` row per didOpen on every
-    // server (python, go, opengrep, ...).
-    const logOutcome = (outcome, metadata = {}) => logLatency({
-        type: "phase",
-        phase: "lsp_typescript_project_identity",
-        filePath: normalizedFile,
-        durationMs: Date.now() - startedAt,
-        metadata: {
-            serverId: options.serverId,
-            launchVariant: options.launchVariant,
-            clientRoot: options.clientRoot,
-            outcome,
-            ...metadata,
-        },
-    });
-    if (options.serverId !== "typescript" ||
-        options.launchVariant !== "classic" ||
-        typeof options.commandChannel.executeCommand !== "function") {
-        return;
-    }
-    if (options.probedFiles.has(normalizedFile))
-        return;
-    // Claim before yielding so concurrent opens cannot issue duplicate probes.
-    options.probedFiles.add(normalizedFile);
-    try {
-        const outcome = await options.commandChannel.executeCommand(TSSERVER_REQUEST_COMMAND, ["projectInfo", { file: options.file, needFileNameList: false }]);
-        if (!outcome.executed) {
-            logOutcome("not-executed");
-            return;
-        }
-        const response = outcome.result;
-        if (!response) {
-            logOutcome("no-response");
-            return;
-        }
-        if (response.success !== true) {
-            logOutcome("unsuccessful");
-            return;
-        }
-        const identity = classifyProjectInfo(response.body);
-        logLatency({
-            type: "phase",
-            phase: "lsp_typescript_project_identity",
-            filePath: normalizedFile,
-            durationMs: Date.now() - startedAt,
-            metadata: {
-                outcome: "ok",
-                serverId: options.serverId,
-                launchVariant: options.launchVariant,
-                clientRoot: options.clientRoot,
-                projectKind: identity.projectKind,
-                configFile: identity.configFile,
-                association: identity.association,
-            },
-        });
-    }
-    catch {
-        logOutcome("threw");
-        // Best-effort telemetry: command errors/timeouts never reach diagnostics.
-    }
-}
-/**
- * #1640: ask tsserver which project owns `file`, on demand, through the same
- * `typescript.tsserverRequest` escape hatch the sync-diagnostics helpers use.
- *
- * Unlike {@link probeTsserverProjectIdentity} — fire-and-forget telemetry
- * sampled once per didOpen — this is a request/response call a caller awaits
- * because it needs the answer to decide how to RENDER a diagnostic.
- *
- * Routed through `executeReadOnlyCommandOnLiveClient` ONLY, never
- * `executeCommand` (#1645 review F1/F2). The mutation channel would open the
- * `workspace/applyEdit` acceptance window, clobber a concurrent command's
- * `activeMutationContext`, carry the 30s mutation backstop instead of the short
- * probe one, and spawn a language-server fleet to answer. All four are wrong for
- * a passive render-path question. A service without the read-only channel is
- * UNKNOWN, not a reason to fall back.
- *
- * Returns `undefined` for every "we do not know" path: no read-only channel, no
- * live server for the file, the command is not advertised (non-classic server,
- * older typescript-language-server), the command was not executed, the response
- * envelope is not `{success:true}`, or the call threw/timed out. `undefined`
- * must never be treated as "inferred" — an unanswered probe is not a verdict
- * (AGENTS.md shape 10: an empty result must distinguish clean from unavailable).
- */
-export async function fetchTsserverProjectIdentity(svc, file) {
-    try {
-        if (typeof svc.executeReadOnlyCommandOnLiveClient !== "function") {
-            return undefined;
-        }
-        // No `getAdvertisedCommands` pre-flight: that helper routes through
-        // `getClientForFile`, which SPAWNS. The read-only channel already enforces
-        // allowlist-by-advertisement server-side and answers `executed:false` for
-        // a server that never advertised the command.
-        const outcome = await svc.executeReadOnlyCommandOnLiveClient(file, TSSERVER_REQUEST_COMMAND, ["projectInfo", { file, needFileNameList: false }]);
-        if (!outcome.executed)
-            return undefined;
-        const response = outcome.result;
-        if (!response || response.success !== true)
-            return undefined;
-        return classifyProjectInfo(response.body);
-    }
-    catch {
-        return undefined;
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function isTsserverSyncRawDiagnostic(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const v = value;
-    return typeof v.message === "string" && typeof v.category === "string";
-}
-function tsserverSeverityFromCategory(category) {
-    switch (category) {
-        case "error":
-            return 1;
-        case "warning":
-            return 2;
-        case "suggestion":
-            return 4; // Hint
-        default:
-            return 3; // "message" or unrecognized -> Info
-    }
-}
-/**
- * Convert a tsserver-protocol sync diagnostic into pi-lens's LSP-shaped
- * `LSPDiagnostic`. Both `line`/`offset` are 1-based in tsserver's protocol
- * and 0-based in LSP — this conversion handles that.
- */
-function tsserverSyncDiagnosticToLsp(d) {
-    const startLine = Math.max(0, (d.startLocation?.line ?? 1) - 1);
-    const startChar = Math.max(0, (d.startLocation?.offset ?? 1) - 1);
-    const endLine = Math.max(0, (d.endLocation?.line ?? d.startLocation?.line ?? 1) - 1);
-    const endChar = Math.max(0, (d.endLocation?.offset ?? d.startLocation?.offset ?? 1) - 1);
-    return {
-        severity: tsserverSeverityFromCategory(d.category),
-        message: d.message,
-        range: {
-            start: { line: startLine, character: startChar },
-            end: { line: endLine, character: endChar },
-        },
-        code: d.code,
-        source: "typescript",
-    };
-}
-/**
- * Run a single tsserver sync diagnostic command via the LSP service's
- * `executeCommand`. Returns the raw diagnostic array from the response body,
- * or `undefined` if: the service has no `executeCommand`, the command wasn't
- * executed, the response envelope isn't `{success:true, body:[...]}`, or
- * any error is thrown.
- */
-async function runTsserverSyncCommand(svc, file, command) {
-    if (typeof svc.executeCommand !== "function")
-        return undefined;
-    const outcome = await svc.executeCommand(file, TSSERVER_REQUEST_COMMAND, [
-        command,
-        { file, includeLinePosition: true },
-    ]);
-    if (!outcome.executed)
-        return undefined;
-    const result = outcome.result;
-    if (!result || result.success !== true || !Array.isArray(result.body)) {
-        return undefined;
-    }
-    return result.body.filter(isTsserverSyncRawDiagnostic);
-}
-/**
- * #611/#707: attempt classic typescript-language-server's
- * `typescript.tsserverRequest` escape hatch — a genuine synchronous
- * request/response tsserver command, not push/timing-dependent — to get a
- * definitive answer for a Tier-3 silent server's empty push-based result.
- * Runs BOTH `semanticDiagnosticsSync` and `syntacticDiagnosticsSync`
- * (mirroring what the server itself publishes on a dirty file) so a
- * syntax-only error isn't missed.
- *
- * Returns `undefined` (never throws, never hangs beyond the existing
- * `executeCommand` anti-deadlock backstop) when: the command isn't advertised
- * by this server (older/different server/config), `executeCommand` throws
- * (live-verified case: tsserver rejects with a `ResponseError` — "No
- * Project." — for a file outside any tsconfig project) or times out, or the
- * response shape isn't the expected `{success:true, body:[...]}` envelope.
- * Every one of these must fall through to the existing "unconfirmed" behavior
- * in the caller.
- *
- * `confirmed: true` with an empty `diagnostics` array = genuinely confirmed
- * clean. `confirmed: true` with a non-empty array = real diagnostics the
- * server had computed but never published (silentOnClean) — these must be
- * surfaced to the caller, not discarded. `confirmed: false` = sync path
- * unavailable, fall through to existing behavior.
- *
- * #2598: `getAdvertisedCommands` is REQUIRED here rather than probed for. The
- * real `LSPService` defines it unconditionally (clients/lsp/index.ts), and both
- * production callers hand this function that service, so the former
- * `typeof … !== "function"` bail was reachable only from a partial test double
- * (AGENTS.md shape 7). It was also unobservable even there: an absent method
- * throws a `TypeError` that this function's own catch turns into the same
- * `undefined` the bail returned. `executeCommand` stays optional on
- * {@link TsserverSyncCapableService} — see {@link runTsserverSyncCommand}.
- */
-export async function attemptTsserverSyncDiagnostics(file, svc) {
-    try {
-        const advertised = await svc.getAdvertisedCommands(file);
-        if (!advertised.includes(TSSERVER_REQUEST_COMMAND))
-            return undefined;
-        const [semantic, syntactic] = await Promise.all([
-            runTsserverSyncCommand(svc, file, "semanticDiagnosticsSync"),
-            runTsserverSyncCommand(svc, file, "syntacticDiagnosticsSync"),
-        ]);
-        if (semantic === undefined || syntactic === undefined)
-            return undefined;
-        return [...syntactic, ...semantic].map(tsserverSyncDiagnosticToLsp);
-    }
-    catch {
-        return undefined;
-    }
-}

package/node_modules/pi-lens/dist/clients/lsp/wait-policy/capability-snapshot.js

@@ -1 +0,0 @@
-export {};