@herbertgao/pi-extensions 2026.9.1 → 2026.9.2

package/node_modules/pi-lens/dist/clients/lsp/index.js

@@ -25,6 +25,7 @@ import { isLspSpawnAllowedByTrust, assertInstallAllowed, projectTrustDenialReaso
 import { shouldPreferPullOnlyDiagnostics } from "../lsp-budget.js";
 import { sampleProcessTreeCpuPercent } from "../resource-sampler.js";
 import { bounded, withDeadline, withTimeout } from "../deadline-utils.js";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
 import { getAmbientAbortSignal } from "../safe-spawn.js";
 import { abortDeferredLspWork } from "../deferred-lsp-work.js";
 import { acquireWorkspaceSweepHold, clearWorkspaceSweepHoldForSessionStart, } from "./workspace-sweep-hold.js";
@@ -646,6 +647,12 @@ export class LSPService {
     /** Server/root pairs that already emitted unavailable for the current occurrence. */
     unavailableLogged = new Set();
     optionalDisabled = new Set();
+    /**
+     * One first-contact diagnostic wait per custom server in this service
+     * generation. Concurrent touches share the probe; a hook cutoff never arms
+     * the navigation-only latch, so the next touch can try again.
+     */
+    firstContactWaits = new Map();
     /**
      * #1934 review F1: what the last COMPLETED `spawnClient` call for a
      * (server, root) key decided, written by that call at every point it
@@ -833,6 +840,8 @@ export class LSPService {
     clientSpawnGate = Promise.resolve();
     /** True after shutdown() has been called; blocks new operations */
     isDestroyed = false;
+    /** Aborts bounded in-flight service work when this generation is retired. */
+    shutdownController = new AbortController();
     /**
      * #850: teardown completion for every singleton generation retired before
      * this service was published. Only replacement services receive one; direct
@@ -852,6 +861,8 @@ export class LSPService {
             clientSpawnedAt: new Map(),
             demonstratedReady: new Set(),
             demonstratedCold: new Set(),
+            diagnosticsPublished: new Set(),
+            diagnosticsUnsupported: new Set(),
         };
     }
     /**
@@ -3117,6 +3128,12 @@ export class LSPService {
             }
             const override = getServerInitOverride(server.id, filePath);
             const mergedInit = mergeInitializationOptions(spawned.initialization, override?.initializationOptions);
+            // A replacement process is a new first-contact identity even when the
+            // configured server id is unchanged. Re-arm both capability latches before
+            // the replacement can publish a snapshot.
+            this.state.diagnosticsPublished.delete(server.id);
+            this.state.diagnosticsUnsupported.delete(server.id);
+            this.firstContactWaits.delete(server.id);
             const client = await createLSPClient({
                 serverId: server.id,
                 process: spawned.process,
@@ -3125,6 +3142,9 @@ export class LSPService {
                 initialization: mergedInit,
                 initializeTimeoutMs: server.initializeTimeoutMs,
                 launchVariant: spawned.launchVariant,
+                onDiagnosticsPublished: (serverId) => {
+                    this.state.diagnosticsPublished.add(serverId);
+                },
             });
             // Guard 2: service was shut down while we were completing the initialize
             // handshake. Shut down the live client best-effort and do not register it.
@@ -3286,6 +3306,11 @@ export class LSPService {
             return;
         }
         const startedAt = Date.now();
+        const hookDeadlineAt = options.hook !== undefined &&
+            Object.hasOwn(HOOK_WALL_BUDGET_MS, options.hook)
+            ? startedAt +
+                HOOK_WALL_BUDGET_MS[options.hook]
+            : undefined;
         const normalizedPath = normalizeMapKey(filePath);
         const outsideRoot = await this.findOutsideProjectRoot(filePath);
         if (outsideRoot) {
@@ -3394,6 +3419,19 @@ export class LSPService {
         if (!leaseKeys) {
             // An idle eviction won between selection and lease admission. Resolve the
             // now-current client set and replay; no notification targets the retiree.
+            if (this.checkDestroyed()) {
+                const primaryServerIds = spawned
+                    .filter((entry) => entry.info.role !== "auxiliary")
+                    .map((entry) => entry.info.id);
+                return {
+                    diags: [],
+                    inconclusive: true,
+                    ...(primaryServerIds.length > 0 && {
+                        inconclusiveServerIds: primaryServerIds,
+                    }),
+                    inconclusiveReason: "diagnostics-wait",
+                };
+            }
             return this.touchFile(filePath, content, options);
         }
         try {
@@ -3791,6 +3829,7 @@ export class LSPService {
             // fallback below may still fill it in on a timed-out empty result).
             let tsserverSyncEligible = false;
             let tsserverSyncConfirmed;
+            let diagnosticsUnsupportedServerIds = [];
             if (diagnosticsMode !== "none") {
                 // Resolution: env wins so users can tune the cap without rebuilding.
                 // Otherwise, on the single-server hot path (primary scope), use that
@@ -3861,6 +3900,9 @@ export class LSPService {
                                 root: entry.client.root,
                                 operationSupport: entry.client.getOperationSupport(),
                                 workspaceDiagnosticsSupport: entry.client.getWorkspaceDiagnosticsSupport(),
+                                customServer: entry.info.custom,
+                                diagnosticsPublished: this.state.diagnosticsPublished.has(entry.info.id),
+                                diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(entry.info.id),
                                 advertisedCommands: entry.client.getAdvertisedCommands(),
                                 rawCapabilityKeys: entry.client.getRawCapabilityKeys?.() ?? [],
                                 launchVariant: entry.client.getLaunchVariant?.(),
@@ -4004,6 +4046,29 @@ export class LSPService {
                 const hasTouchAuxiliaries = clientScope === "with-auxiliary" &&
                     options.collectDiagnostics === true &&
                     spawned.some((e) => e.info.role === "auxiliary");
+                if (spawned.some((entry) => entry.info.custom === true)) {
+                    try {
+                        const snapshotHook = options.hook ?? "tool_result_edit";
+                        const snapshotBudget = hookDeadlineAt === undefined
+                            ? HOOK_WALL_BUDGET_MS.tool_result_edit
+                            : Math.max(0, hookDeadlineAt - Date.now());
+                        const snapshots = await bounded(this.getCapabilitySnapshots(filePath), {
+                            ms: snapshotBudget,
+                            signal: getAmbientAbortSignal(),
+                            shutdownSignal: this.shutdownController.signal,
+                            hook: snapshotHook,
+                            label: `getCapabilitySnapshots:${filePath}`,
+                        });
+                        if (snapshots !== undefined) {
+                            diagnosticsUnsupportedServerIds = spawned
+                                .filter((entry) => classifyServerWaitTier(entry.info.id, snapshots.find((s) => s.serverId === entry.info.id)) === "diagnostics-unsupported")
+                                .map((entry) => entry.info.id);
+                        }
+                    }
+                    catch {
+                        // Capability uncertainty fails closed and retains the wait.
+                    }
+                }
                 // Per-server wait promises (each already bounded by its own
                 // perServerTimeout — unchanged from before R8).
                 let pressureSnapshots = [];
@@ -4028,12 +4093,33 @@ export class LSPService {
                         ? auxWaitBudgetMs(entry.client.serverId, true, configuredAuxCeilingMs, declaredServerTimeout)
                         : perServerDeclaredTimeouts[entryIndex];
                 });
+                const firstContactCutOffServerIds = new Set();
+                const firstContactErroredServerIds = new Set();
+                const answeredForThisTouch = (entry) => {
+                    const baseline = diagnosticBaselines.get(entry.client);
+                    const currentPathVersion = readPathVersion(entry.client);
+                    if (Number.isFinite(baseline) &&
+                        currentPathVersion !== undefined &&
+                        currentPathVersion > baseline) {
+                        return true;
+                    }
+                    try {
+                        return (entry.client.getAllDiagnostics?.().has(normalizedPath) === true);
+                    }
+                    catch {
+                        return false;
+                    }
+                };
                 const perServerRaceBudgets = spawned.map((entry, entryIndex) => {
                     return hasTouchAuxiliaries && entry.info.role === "auxiliary"
                         ? auxWaitBudgetMs(entry.client.serverId, coldAuxiliaryServerIds.has(entry.client.serverId), configuredAuxCeilingMs, perServerDeclaredTimeouts[entryIndex])
                         : perServerDeclaredTimeouts[entryIndex];
                 });
                 const perServerWaits = spawned.map((entry, entryIndex) => {
+                    if (this.state.diagnosticsUnsupported.has(entry.info.id) ||
+                        diagnosticsUnsupportedServerIds.includes(entry.info.id)) {
+                        return Promise.resolve(undefined);
+                    }
                     // #1459: a DEFERRED server never received this content, so its version
                     // can never advance past the baseline — waiting on it burns its whole
                     // budget and would flip the touch to `inconclusive`, discarding a
@@ -4063,7 +4149,7 @@ export class LSPService {
                     const isWarmupTouch = source === "lsp_sweep_warmup";
                     // #743: per-server — a server we DID push to still gets the
                     // version-baseline wait even when a sibling was debounced away.
-                    const wait = !notifySkippedServerIds.has(entry.info.id) &&
+                    const waitForDiagnostics = () => !notifySkippedServerIds.has(entry.info.id) &&
                         Number.isFinite(baseline)
                         ? entry.client.waitForDiagnostics(filePath, serverTimeout, {
                             minVersion: baseline,
@@ -4080,7 +4166,73 @@ export class LSPService {
                                     pullSettleSource: "pull-warmup",
                                 })
                                 : entry.client.waitForDiagnostics(filePath, serverTimeout);
-                    return wait.catch(() => undefined);
+                    const firstContact = entry.info.custom === true &&
+                        !this.state.diagnosticsPublished.has(entry.info.id) &&
+                        !this.state.diagnosticsUnsupported.has(entry.info.id) &&
+                        entry.client.getWorkspaceDiagnosticsSupport().mode !== "pull";
+                    if (!firstContact)
+                        return waitForDiagnostics().catch(() => undefined);
+                    let shared = this.firstContactWaits.get(entry.info.id);
+                    if (!shared) {
+                        let removeShutdownListener;
+                        const shutdown = new Promise((resolve) => {
+                            const onShutdown = () => resolve("shutdown");
+                            if (this.shutdownController.signal.aborted) {
+                                onShutdown();
+                                return;
+                            }
+                            this.shutdownController.signal.addEventListener("abort", onShutdown, {
+                                once: true,
+                            });
+                            removeShutdownListener = () => this.shutdownController.signal.removeEventListener("abort", onShutdown);
+                        });
+                        const probe = Promise.race([
+                            waitForDiagnostics().then(() => "completed", () => "errored"),
+                            shutdown,
+                        ]);
+                        const completed = withDeadline(probe, {
+                            ms: serverTimeout,
+                            onTimeout: "undefined",
+                        });
+                        shared = completed
+                            .then((outcome) => {
+                            if (outcome === "errored" || outcome === "shutdown") {
+                                return "errored";
+                            }
+                            if (answeredForThisTouch(entry))
+                                return "answered";
+                            this.state.diagnosticsUnsupported.add(entry.info.id);
+                            recordDegradationOnce({
+                                kind: "lsp-diagnostics-unsupported",
+                                subject: entry.info.id,
+                                reason: "custom server has no pull provider and no publish evidence after first contact wait",
+                            });
+                            return "silent";
+                        })
+                            .catch(() => "errored")
+                            .finally(() => {
+                            removeShutdownListener?.();
+                            if (this.firstContactWaits.get(entry.info.id) === shared) {
+                                this.firstContactWaits.delete(entry.info.id);
+                            }
+                        });
+                        this.firstContactWaits.set(entry.info.id, shared);
+                    }
+                    const callerWait = hookDeadlineAt === undefined
+                        ? shared
+                        : withDeadline(shared, {
+                            ms: Math.max(0, hookDeadlineAt - Date.now()),
+                            onTimeout: "undefined",
+                        });
+                    return callerWait.then((outcome) => {
+                        if (outcome === undefined) {
+                            firstContactCutOffServerIds.add(entry.info.id);
+                        }
+                        else if (outcome === "errored") {
+                            firstContactErroredServerIds.add(entry.info.id);
+                        }
+                        return undefined;
+                    });
                 });
                 // The push wait — same per-server budget composition as before #707;
                 // only the awaiting changed (assigned so it can be raced below).
@@ -4257,9 +4409,14 @@ export class LSPService {
                         });
                     })()
                     : Promise.all(perServerWaits).then(() => { });
-                pushWait.then(() => {
+                // Mark on BOTH paths: a rejected `pushWait` is settled too, and a
+                // resolve-only `.then` left a derived promise that rejected unhandled
+                // whenever a per-server wait failed (oxlint no-floating-promises,
+                // 2026-09-07). The rejection itself still reaches the awaiters below.
+                const markPushWaitSettled = () => {
                     pushWaitSettled = true;
-                });
+                };
+                void pushWait.then(markPushWaitSettled, markPushWaitSettled);
                 if (tsserverSyncEligible) {
                     // #707 racing variant: rather than burning the full push-wait budget
                     // on a silent-on-clean server (which by definition never answers on a
@@ -4331,6 +4488,35 @@ export class LSPService {
                     await pushWait;
                 }
                 const waitedMs = Date.now() - waitStartedAt;
+                const firstContactCustomServerIds = spawned
+                    .filter((entry) => entry.info.custom === true &&
+                    !this.state.diagnosticsPublished.has(entry.info.id) &&
+                    !this.state.diagnosticsUnsupported.has(entry.info.id) &&
+                    !firstContactCutOffServerIds.has(entry.info.id) &&
+                    !firstContactErroredServerIds.has(entry.info.id) &&
+                    entry.client.getWorkspaceDiagnosticsSupport().mode !== "pull")
+                    .map((entry) => entry.info.id);
+                for (const serverId of firstContactCustomServerIds) {
+                    const entry = spawned.find((candidate) => candidate.info.id === serverId);
+                    if (!entry || answeredForThisTouch(entry))
+                        continue;
+                    this.state.diagnosticsUnsupported.add(serverId);
+                    diagnosticsUnsupportedServerIds.push(serverId);
+                    recordDegradationOnce({
+                        kind: "lsp-diagnostics-unsupported",
+                        subject: serverId,
+                        reason: "custom server has no pull provider and no publish evidence after first contact wait",
+                    });
+                }
+                for (const entry of spawned) {
+                    if (entry.info.custom === true &&
+                        this.state.diagnosticsUnsupported.has(entry.info.id)) {
+                        diagnosticsUnsupportedServerIds.push(entry.info.id);
+                    }
+                }
+                diagnosticsUnsupportedServerIds = [
+                    ...new Set(diagnosticsUnsupportedServerIds),
+                ];
                 // #1533: the same auxiliary coverage evidence for a collecting touch that
                 // did NOT enter the aux-grace wait — in practice `clientScope: "all"`, the
                 // batch/directory scan surface. Auxiliaries ARE spawned on that scope
@@ -4454,7 +4640,8 @@ export class LSPService {
                         },
                     });
                 }
-                else if (waitedMs + 20 >= timeoutMs) {
+                else if (waitedMs + 20 >= timeoutMs ||
+                    firstContactErroredServerIds.size > 0) {
                     // Within ~20 ms of the configured budget we treat it as a timeout;
                     // the LSP didn't beat the cap. Diagnostics that arrive late still
                     // land in the client's cache and surface on the next edit.
@@ -4479,25 +4666,10 @@ export class LSPService {
                     // reads as unanswered, which for a primary is exactly the pre-#1549
                     // verdict. This block can therefore only ever NARROW an inconclusive
                     // touch, never create one.
-                    const answeredForThisTouch = (entry) => {
-                        const baseline = diagnosticBaselines.get(entry.client);
-                        const currentPathVersion = readPathVersion(entry.client);
-                        if (Number.isFinite(baseline) &&
-                            currentPathVersion !== undefined &&
-                            currentPathVersion > baseline) {
-                            return true;
-                        }
-                        try {
-                            return (entry.client.getAllDiagnostics?.().has(normalizedPath) === true);
-                        }
-                        catch {
-                            // Fail closed: an unreadable cache is not evidence of an answer.
-                            return false;
-                        }
-                    };
                     // A deferred server was never sent this content and is not waited on, so
                     // it cannot have "timed out" — it is already reported as a coverage gap.
-                    const waited = spawned.filter((entry) => !deferredResyncServerIds.has(entry.info.id));
+                    const waited = spawned.filter((entry) => !deferredResyncServerIds.has(entry.info.id) &&
+                        !diagnosticsUnsupportedServerIds.includes(entry.info.id));
                     const unanswered = waited.filter((entry) => !answeredForThisTouch(entry));
                     diagnosticsUnansweredServerIds = unanswered.map((e) => e.info.id);
                     diagnosticsUnansweredPrimaryServerIds = unanswered
@@ -4507,8 +4679,9 @@ export class LSPService {
                     // preserve, so it keeps the pre-#1549 touch-wide verdict rather than
                     // absolving itself on an auxiliary's evidence.
                     const hasWaitedPrimary = waited.some((entry) => entry.info.role !== "auxiliary");
+                    const hasUnsupportedPrimary = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
                     diagnosticsTimedOut =
-                        !hasWaitedPrimary ||
+                        (!hasWaitedPrimary && !hasUnsupportedPrimary) ||
                             diagnosticsUnansweredPrimaryServerIds.length > 0;
                     for (const entry of unanswered) {
                         incrementDegradationCount({
@@ -5061,6 +5234,11 @@ export class LSPService {
             // collect, `binding` only for a collecting touch — a non-collecting touch
             // keeps resolving `{ diags: [] }`, no flags.
             const result = { diags: collected ?? [] };
+            const primaryDiagnosticsUnsupported = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
+            if (diagnosticsUnsupportedServerIds.length > 0) {
+                result.diagnosticsUnsupportedServerIds =
+                    diagnosticsUnsupportedServerIds;
+            }
             if (collected !== undefined && inconclusive) {
                 result.inconclusive = true;
                 // #1549: name the primary that produced the verdict and which deadline it
@@ -5073,6 +5251,11 @@ export class LSPService {
                 }
                 result.inconclusiveReason = verdict.inconclusiveReason;
             }
+            else if (collected !== undefined && primaryDiagnosticsUnsupported) {
+                // A navigation-only primary has no diagnostic confirmation to report.
+                // Auxiliary coverage cannot turn that capability boundary into a clean
+                // or partial diagnostic verdict.
+            }
             else if (collected !== undefined && coverageGap) {
                 // #1470/#1493: narrowed, not collapsed. Reached for EITHER no-answer
                 // shape — a cut-off auxiliary or a silent one with nothing published for
@@ -5083,7 +5266,7 @@ export class LSPService {
                 result.confirmation = "partial";
                 result.unconfirmedServerIds = [...unconfirmedServerIds];
             }
-            else if (collected !== undefined) {
+            else if (collected !== undefined && !primaryDiagnosticsUnsupported) {
                 // Preserve the lower-level affirmative result across consumers. In
                 // particular, the silent-clean gates above clear diagnosticsTimedOut only
                 // after a successful notify and capability-confirmed wait; reclassifying
@@ -5854,6 +6037,9 @@ export class LSPService {
                     root,
                     operationSupport: client.getOperationSupport(),
                     workspaceDiagnosticsSupport: client.getWorkspaceDiagnosticsSupport(),
+                    customServer: server.custom,
+                    diagnosticsPublished: this.state.diagnosticsPublished.has(server.id),
+                    diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(server.id),
                     advertisedCommands: client.getAdvertisedCommands(),
                     rawCapabilityKeys: client.getRawCapabilityKeys?.() ?? [],
                     launchVariant: client.getLaunchVariant?.(),
@@ -5871,6 +6057,9 @@ export class LSPService {
                 root: client.root,
                 operationSupport: client.getOperationSupport(),
                 workspaceDiagnosticsSupport: client.getWorkspaceDiagnosticsSupport(),
+                customServer: this.state.servers.get(serverId)?.custom,
+                diagnosticsPublished: this.state.diagnosticsPublished.has(serverId),
+                diagnosticsUnsupported: this.state.diagnosticsUnsupported.has(serverId),
                 advertisedCommands: client.getAdvertisedCommands(),
                 rawCapabilityKeys: client.getRawCapabilityKeys?.() ?? [],
                 launchVariant: client.getLaunchVariant?.(),
@@ -7042,7 +7231,7 @@ export class LSPService {
         // ONE bracket for the whole fan-out, not one per file (#2272 review F1).
         // Per-file bracketing was the first shape and it was inert for exactly
         // the case above: `phaseFinished` pushes onto a ring capped at
-        // `CLOSED_BRACKET_CAP` (5, clients/latency-logger.ts), while `turn_end`
+        // `RECENT_PHASE_CAP` (5, clients/latency-logger.ts), while `turn_end`
         // reads `getPhaseForWindow` AFTER the sweep returns. A 225-file sweep
         // therefore evicted the blocking file's own bracket unless the block
         // landed in the last five files, and the survivors were then rejected by
@@ -7515,6 +7704,7 @@ export class LSPService {
         if (this.checkDestroyed())
             return;
         this.isDestroyed = true;
+        this.shutdownController.abort();
         for (const [key, token] of this.outstandingAuxNotifyWrites) {
             this.releaseOutstandingAuxNotifyWrite(key, token);
         }
@@ -7563,6 +7753,7 @@ export class LSPService {
         });
         this.state.clients.clear();
         this.state.broken.clear();
+        this.firstContactWaits.clear();
         // #1934 review F1: map hygiene alongside the breaker it sits next to.
         // Not load-bearing — every read follows its own attempt's write — but a
         // verdict for a client generation that no longer exists is dead weight.

package/node_modules/pi-lens/dist/clients/lsp/inferred-project.js

@@ -55,7 +55,7 @@ const TYPESCRIPT_DIAGNOSTIC_SOURCES = new Set(["typescript", "ts", "tsserver"]);
 export function isTsProjectFile(filePath) {
     return TS_PROJECT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
-export function isTypeScriptSourcedDiagnostic(d) {
+function isTypeScriptSourcedDiagnostic(d) {
     return TYPESCRIPT_DIAGNOSTIC_SOURCES.has((d.source ?? "").toLowerCase());
 }
 /**

package/node_modules/pi-lens/dist/clients/lsp/language.js

@@ -61,11 +61,3 @@ export function getLanguageId(filePath) {
         LANGUAGE_EXTENSIONS[base.toLowerCase()] ??
         getBasenameLanguageId(base));
 }
-/**
- * Get all extensions for a language ID
- */
-export function getExtensionsForLanguage(languageId) {
-    return Object.entries(LANGUAGE_EXTENSIONS)
-        .filter(([, id]) => id === languageId)
-        .map(([ext]) => ext);
-}

package/node_modules/pi-lens/dist/clients/lsp/path-utils.js

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

package/node_modules/pi-lens/dist/clients/lsp/pending-aux-coverage.js

@@ -187,8 +187,6 @@ export function drainPendingAuxiliaryCoverage() {
 export function pendingAuxiliaryCoverageSize() {
     return pending.size;
 }
-/** Test-only alias for the store-size assertion seam. */
-export const pendingAuxiliaryCoverageSizeForTests = pendingAuxiliaryCoverageSize;
 /**
  * Drain (read and reset) the cap-eviction count accumulated since the last
  * drain. Mirrors {@link drainPendingAuxiliaryCoverage}'s consume-once shape

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

@@ -16,7 +16,6 @@
  * always sent, so an unrecognized/absent value never regresses `Full`/`None`
  * behavior.
  */
-export const TEXT_DOCUMENT_SYNC_KIND_NONE = 0;
 export const TEXT_DOCUMENT_SYNC_KIND_FULL = 1;
 export const TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL = 2;
 function isSyncKind(value) {

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

@@ -37,7 +37,7 @@ import { normalizeMapKey } from "../path-utils.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-export const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
+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
@@ -219,13 +219,13 @@ export async function fetchTsserverProjectIdentity(svc, file) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-export function isTsserverSyncRawDiagnostic(value) {
+function isTsserverSyncRawDiagnostic(value) {
     if (!value || typeof value !== "object")
         return false;
     const v = value;
     return typeof v.message === "string" && typeof v.category === "string";
 }
-export function tsserverSeverityFromCategory(category) {
+function tsserverSeverityFromCategory(category) {
     switch (category) {
         case "error":
             return 1;
@@ -242,7 +242,7 @@ export function tsserverSeverityFromCategory(category) {
  * `LSPDiagnostic`. Both `line`/`offset` are 1-based in tsserver's protocol
  * and 0-based in LSP — this conversion handles that.
  */
-export function tsserverSyncDiagnosticToLsp(d) {
+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);
@@ -265,7 +265,7 @@ export function tsserverSyncDiagnosticToLsp(d) {
  * executed, the response envelope isn't `{success:true, body:[...]}`, or
  * any error is thrown.
  */
-export async function runTsserverSyncCommand(svc, file, command) {
+async function runTsserverSyncCommand(svc, file, command) {
     if (typeof svc.executeCommand !== "function")
         return undefined;
     const outcome = await svc.executeCommand(file, TSSERVER_REQUEST_COMMAND, [

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

@@ -24,6 +24,12 @@ export function classifyServerWaitTier(serverId, snapshot) {
     const mode = snapshot.workspaceDiagnosticsSupport?.mode;
     if (mode === "pull")
         return "pull-capable";
+    if (snapshot.customServer === true &&
+        mode === "push-only" &&
+        snapshot.diagnosticsUnsupported === true &&
+        snapshot.diagnosticsPublished !== true) {
+        return "diagnostics-unsupported";
+    }
     if (mode !== "push-only")
         return "waits";
     const strategy = getStrategy(serverId, snapshot.launchVariant);

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

@@ -73,6 +73,7 @@ export function resolveAstGrepNativeExe(platform = process.platform, arch = proc
         return undefined;
     }
 }
+/** @public — loaded by scripts/probe-clean-signal.mjs through a dynamic import wrapper knip cannot see. */
 export const SERVER_DIAGNOSTIC_STRATEGIES = {
     typescript: {
         seedFirstPush: true,
@@ -287,7 +288,7 @@ const NATIVE_TS7_DIAGNOSTIC_STRATEGY = {
     silentOnClean: false,
 };
 /** Fallback for unknown servers. Conservative defaults. */
-export const DEFAULT_STRATEGY = {
+const DEFAULT_STRATEGY = {
     seedFirstPush: false,
     pullRetryBudgetMs: 250,
     debounceMs: 150,

package/node_modules/pi-lens/dist/clients/lsp-document-symbols.js

@@ -2,7 +2,7 @@ import { getLSPService } from "./lsp/index.js";
 // Grounded against this repo's workspace-native TypeScript 7.0.2 server
 // (`tsc --lsp --stdio`) on 2026-07-30: 20 already-open documentSymbol calls
 // measured p50 3.70 ms / p95 5.28 ms. Keep generous headroom for slower hosts.
-export const LSP_DOCUMENT_SYMBOL_TIMEOUT_MS = 150;
+const LSP_DOCUMENT_SYMBOL_TIMEOUT_MS = 150;
 export const SYMBOL_KIND_NAMES = {
     1: "file",
     2: "module",