pi-lens 4.3.0 → 4.4.0

package/dist/clients/lsp/wait-policy/classification.js

@@ -1,85 +0,0 @@
-/**
- * Incumbent LSP wait-tier policy for attached sessions (#822).
- *
- * This policy is applied by the incumbent process on behalf of attached
- * sessions. Keep it free of session-local state: no imports from
- * runtime-session, runtime-turn, or warm-attach.
- */
-import { getServersForFileWithConfig } from "../config.js";
-import { getStrategy } from "./strategies.js";
-/**
- * Classify a SINGLE server (by id, given its live capability snapshot — or
- * `undefined` when none exists yet) as cascade-lane Tier-3 (push-only,
- * silent-on-clean) or not. This is the per-server primitive both
- * `classifyCascadeWaitTier` (file's PRIMARY server only, the cascade lane's
- * original use) and #814's capability-aware AGGREGATE wait (`touchFile`'s
- * `clientScope: "all"` path, `clients/lsp/index.ts`) share — one
- * classification rule, not two copies that could drift. Ambiguous or missing
- * capability data is always `"waits"` (today's behavior) — this function must
- * never be the reason a real answer gets missed.
- */
-export function classifyServerWaitTier(serverId, snapshot) {
-    if (!snapshot)
-        return "waits"; // no live snapshot yet — fail-safe
-    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);
-    if (strategy.silentOnClean !== true)
-        return "waits"; // 2*/unknown push-only
-    // #524/#529/#541/#558: `silentOnClean` on a server-id-keyed strategy is
-    // only proven against the variant it was actually measured against.
-    // "typescript" today means either classic typescript-language-server
-    // (confirmed silent-on-clean, 2026-07-12 dual-environment re-measurement)
-    // or TS7's native `tsc --lsp --stdio` (the SAME re-measurement found it
-    // publishes 2 version-less diagnostic sets on clean — NOT silent, a
-    // drift from the earlier #541 measurement). A native-ts7 snapshot must
-    // NOT inherit the classic verdict: fall through to "waits", the same
-    // ambiguous/fail-safe path an unmarked or non-push-only server already
-    // takes. `launchVariant === "classic"` or absent (older snapshots that
-    // predate the marker) keeps today's tier-3 behavior exactly.
-    if (snapshot.launchVariant === "native-ts7")
-        return "waits";
-    return "tier3-silent";
-}
-/**
- * Resolve `filePath`'s PRIMARY (non-auxiliary) server id and its live
- * capability snapshot, or `undefined` when the file has no primary server
- * configured. The single place that decides what "this file's server" means
- * for wait-policy purposes — shared by {@link classifyCascadeWaitTier} and the
- * cascade-lane wrapper in `clients/lsp/cascade-tier.ts`, which needs the same
- * id/snapshot pair to apply its one cascade-only override.
- */
-export function resolvePrimaryServerForWaitPolicy(filePath, snapshots) {
-    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
-    const primary = servers[0];
-    if (!primary)
-        return undefined;
-    return {
-        serverId: primary.id,
-        snapshot: snapshots.find((s) => s.serverId === primary.id),
-    };
-}
-/**
- * Classify whether `filePath`'s PRIMARY language server is a cascade-lane
- * Tier-3 (push-only, silent-on-clean) server. Ambiguous or missing capability
- * data is always `"waits"` (today's behavior) — this function must never be
- * the reason a real answer gets missed. Thin wrapper over
- * `classifyServerWaitTier` — resolves the file's primary server id/snapshot,
- * then defers to the shared per-server rule.
- */
-export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
-    void lspService; // kept in the signature for call-site clarity/typing only
-    const primary = resolvePrimaryServerForWaitPolicy(filePath, snapshots);
-    if (!primary)
-        return "waits";
-    return classifyServerWaitTier(primary.serverId, primary.snapshot);
-}

package/dist/clients/lsp/wait-policy/index.js

@@ -1,10 +0,0 @@
-/**
- * Incumbent-owned LSP wait policy and capability inventory boundary (#822).
- *
- * The incumbent applies this policy when it serves attached sessions. Keep
- * this boundary process-neutral and free of session-local state: do not import
- * runtime-session, runtime-turn, or warm-attach here.
- */
-export * from "./capability-snapshot.js";
-export * from "./classification.js";
-export * from "./strategies.js";

package/dist/clients/lsp/wait-policy/strategies.js

@@ -1,392 +0,0 @@
-/**
- * Incumbent LSP wait policy for attached sessions (#822).
- *
- * The incumbent process applies this policy on behalf of every attached
- * session. Keep this module free of session-local state: it must not import
- * runtime-session, runtime-turn, or warm-attach.
- *
- * Per-Server Diagnostic Strategies for pi-lens LSP
- *
- * Codifies known server behavior so timing decisions (debounce, retry budget,
- * first-push seeding) are automatic rather than one-size-fits-all.
- *
- * Env var overrides (PI_LENS_LSP_*) always take precedence over strategy values.
- */
-import { createRequire } from "node:module";
-const _require = createRequire(import.meta.url);
-/**
- * Platform/arch → `@ast-grep/cli-<platform>-<arch>[-msvc|-gnu]` native
- * package name, mirroring @ast-grep/cli's own `optionalDependencies` matrix
- * (checked directly against node_modules/@ast-grep/cli/package.json). Each
- * package ships the native `ast-grep`/`ast-grep.exe` binary at its package
- * root (no `bin/` subdir) — see node_modules/@ast-grep/cli-win32-x64-msvc/.
- */
-function astGrepNativePackageName(platform, arch) {
-    switch (platform) {
-        case "win32":
-            if (arch === "x64")
-                return "@ast-grep/cli-win32-x64-msvc";
-            if (arch === "arm64")
-                return "@ast-grep/cli-win32-arm64-msvc";
-            if (arch === "ia32")
-                return "@ast-grep/cli-win32-ia32-msvc";
-            return undefined;
-        case "darwin":
-            if (arch === "arm64")
-                return "@ast-grep/cli-darwin-arm64";
-            if (arch === "x64")
-                return "@ast-grep/cli-darwin-x64";
-            return undefined;
-        case "linux":
-            if (arch === "x64")
-                return "@ast-grep/cli-linux-x64-gnu";
-            if (arch === "arm64")
-                return "@ast-grep/cli-linux-arm64-gnu";
-            return undefined;
-        default:
-            return undefined;
-    }
-}
-/**
- * Resolve ast-grep's platform-native exe DIRECTLY, skipping the node-bin
- * wrapper (`ast-grep.cmd`/shim → node → cli.js → spawn native exe). One less
- * orphanable process layer (#472): a wrapper's direct child is the node/cmd
- * process, so on abnormal exit the actual ast-grep binary is a grandchild the
- * #234 teardown path never reaches — resolving straight to the native exe
- * means the LSP's direct child IS the real server.
- *
- * `require.resolve` is wrapped in try/catch (ESM-safe via createRequire, same
- * pattern as clients/deps/ast-grep-napi.ts) — returns undefined so the caller
- * falls back to the existing wrapper-based resolution when the platform
- * package isn't installed (it's an optionalDependency; native builds can be
- * absent on unsupported platforms/arches or a partial install).
- */
-export function resolveAstGrepNativeExe(platform = process.platform, arch = process.arch) {
-    const pkgName = astGrepNativePackageName(platform, arch);
-    if (!pkgName)
-        return undefined;
-    const binaryName = platform === "win32" ? "ast-grep.exe" : "ast-grep";
-    try {
-        return _require.resolve(`${pkgName}/${binaryName}`);
-    }
-    catch {
-        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,
-        pullRetryBudgetMs: 0,
-        debounceMs: 50,
-        aggregateWaitMs: 1000,
-        expectSemanticSecondPush: false,
-        // Tier 3 (#458): typescript-language-server publishes nothing on a
-        // clean→clean edit (docs/lsp-capability-matrix.md, re-confirmed
-        // 2026-07-12). It's the lone core-set tier-3 server, which is exactly
-        // why the cascade lane's in-lane wait is worth skipping for it
-        // specifically. Applies to the CLASSIC server only (#524/#529/#558)
-        // — TS7's native `tsc --lsp --stdio` variant shares this
-        // "typescript" server id but the 2026-07-12 dual-environment
-        // re-measurement found it now publishes on clean (a drift from the
-        // #541 measurement); wait-policy/classification.ts's classifier checks the live
-        // snapshot's launchVariant and never applies this flag to a
-        // native-ts7 instance.
-        silentOnClean: true,
-    },
-    "rust-analyzer": {
-        seedFirstPush: false,
-        pullRetryBudgetMs: 500,
-        debounceMs: 150,
-        aggregateWaitMs: 3000,
-        expectSemanticSecondPush: true,
-    },
-    // PythonServer (pyright / basedpyright) — openFilesOnly mode: lazy per-file
-    // analysis, startup similar to jedi. seedFirstPush: true because pyright's
-    // first publishDiagnostics after didOpen is the complete result for that file.
-    python: {
-        seedFirstPush: true,
-        pullRetryBudgetMs: 0,
-        debounceMs: 100,
-        aggregateWaitMs: 1500,
-        expectSemanticSecondPush: false,
-    },
-    // jedi-language-server is push-only (no pull diagnostics) and its FIRST
-    // publishDiagnostics is the complete result (seedFirstPush). But that first
-    // push lands just after didOpen+~1s on cold start (Python/parso import) —
-    // measured ~1011ms — so a 1000ms aggregate budget misses it by a hair and
-    // returns zero. 3000ms gives cold-start headroom without stalling the warm path.
-    "python-jedi": {
-        seedFirstPush: true,
-        pullRetryBudgetMs: 0,
-        debounceMs: 100,
-        aggregateWaitMs: 3000,
-        expectSemanticSecondPush: false,
-    },
-    eslint: {
-        seedFirstPush: true,
-        pullRetryBudgetMs: 0,
-        debounceMs: 200,
-        aggregateWaitMs: 2000,
-        expectSemanticSecondPush: false,
-    },
-    // Opengrep security scanner (cross-language LSP). It pushes an EMPTY result
-    // during the one-time rule-load window at startup, then the real scan after
-    // `semgrep/rulesRefreshed` — so never seed the first push. Push-only (no pull
-    // diagnostics). Warm per-file scan ~1.3s; the first touch in a session may
-    // also pay rule-load (~3.5s cold). aggregateWaitMs is 3500: it's this
-    // server's OWN deadline, bounded by the per-edit caller cap as a ceiling
-    // (#242), so on a 2500ms-capped edit opengrep waits min(2500, 3500)=2500
-    // and on uncapped paths it gets its full 3500. 3500 covers warm and most
-    // cold; a cold scan that overruns isn't lost — late diagnostics are cached
-    // and surface on the next unchanged-content read through the content-bound
-    // auxiliary carry-over path.
-    opengrep: {
-        seedFirstPush: false,
-        pullRetryBudgetMs: 0,
-        debounceMs: 250,
-        aggregateWaitMs: 3500,
-        expectSemanticSecondPush: false,
-        // Opengrep re-scans only on a fresh didOpen — didChange is a no-op for it.
-        reopenOnResync: true,
-    },
-    // ast-grep structural linter (sgconfig-gated auxiliary LSP). Push-only,
-    // compiles the project rules on the first scan of a session, and — like
-    // Opengrep — is re-synced via didClose+didOpen so edits trigger a re-scan.
-    // Conservative budget until measured against real projects (#239).
-    // ast-grep re-scans on didChange (verified: toggling the violation count
-    // 3→1→4→2 returns the correct fresh count each touch, with matching doc
-    // versions), so reopen isn't needed and didChange is the lighter path.
-    // aggregateWaitMs is 1800: its warm scan is ~1.3s, so 1000 was under-budgeted
-    // (only masked before because the old with-auxiliary deadline was a global
-    // max() floor; now each server has its own caller-cap-bounded deadline, #242,
-    // so the budget must actually cover the scan).
-    "ast-grep": {
-        seedFirstPush: false,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 1800,
-        expectSemanticSecondPush: false,
-        reopenOnResync: false,
-    },
-    // zizmor (GitHub Actions security scanner, auxiliary LSP #272). Push-only
-    // (no pull diagnostics). Its audit set is compiled-in — there's no rule-load
-    // window like Opengrep — so the FIRST publishDiagnostics after didOpen IS the
-    // complete result: seedFirstPush. It re-scans on didChange (FULL sync), so no
-    // reopen-on-resync. A native single-workflow audit is sub-second offline;
-    // online mode may add a GitHub-API round-trip, so 2000ms gives headroom
-    // (bounded by the per-edit caller cap as a ceiling, #242), and any late online
-    // finding can surface on the next unchanged-content read through the
-    // content-bound auxiliary carry-over path.
-    zizmor: {
-        seedFirstPush: true,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 2000,
-        expectSemanticSecondPush: false,
-        reopenOnResync: false,
-    },
-    // typos (source-code spell checker, auxiliary LSP #283). Push-only (no pull
-    // diagnostics). Its dictionary is compiled in — there's NO rule-load window
-    // like Opengrep — so the FIRST publishDiagnostics after didOpen IS the
-    // complete result: seedFirstPush. It re-scans on didChange (FULL sync), so no
-    // reopen-on-resync. A native single-file spell scan is sub-100ms, so the seed
-    // arrives near-instantly; aggregateWaitMs is a generous ceiling (bounded by
-    // the per-edit caller cap, #242) that the early seed resolves well under.
-    typos: {
-        seedFirstPush: true,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 1500,
-        expectSemanticSecondPush: false,
-        reopenOnResync: false,
-    },
-    // marksman (Markdown LSP, #274). Push-based; native binary so the per-file
-    // parse is fast, but its value is CROSS-file (broken intra-repo links,
-    // missing anchors/heading refs) which needs the workspace index — so the
-    // first push after didOpen can be empty before indexing completes. Don't
-    // seed it (like opengrep/rust-analyzer); a modest 1500ms aggregate covers
-    // warm edits, and any late cross-file finding surfaces on the next touch.
-    marksman: {
-        seedFirstPush: false,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 1500,
-        expectSemanticSecondPush: false,
-        // #645: a full-tree sweep opens every markdown file, all racing the
-        // SAME one-time workspace index build — pay the 1500ms budget once
-        // per sweep (the first markdown file touched), not once per file.
-        // 250ms covers a warm per-file publish (native binary, fast parse)
-        // once the index has already had a full aggregateWaitMs window.
-        workspaceIndexing: true,
-        workspaceIndexingWarmWaitMs: 250,
-        // #799 / run 35914033696: marksman is push-only and publishes NOTHING on
-        // a clean transition — there is no pull fallback and no sync-confirm protocol (unlike
-        // typescript's tsserver commands), so a clean markdown file's touch
-        // waits its full budget with zero signal either way. Marking it
-        // `silentOnClean` lets the generic push-only clean-confirm gate
-        // (`touchFile`, the `classifyCascadeWaitTier`-driven fallback next to
-        // the tsserver sync-confirm block) treat "no publish within budget,
-        // notify succeeded" as CONFIRMED clean instead of inconclusive/timed
-        // out — closing the observed 2x20s-per-sweep burn on clean markdown
-        // (evidence: agents.md timed out at 20009ms/20014ms on both the
-        // warm-up attempt and its retry, with zero diagnostics either time).
-        silentOnClean: true,
-    },
-    // cue lsp serve (#1522, #1519, #1520). Measured directly against the real
-    // v0.17.1 binary (`getWorkspaceDiagnosticsSupport` reports
-    // `mode: "push-only"`; no pull support advertised).
-    //
-    // It reports load/parse (syntax) errors as you type, but leaves
-    // conflicting-value/constraint-failure (evaluation) errors to `cue vet`
-    // — the #1522 cue-vet auxiliary runner covers that gap. So the syntax
-    // diagnostics this strategy governs are a REAL but PARTIAL signal, not
-    // full CUE validation.
-    //
-    // The repaired clean-signal probe measured cue as publishing a versioned
-    // clean-transition set (run 35914033696), so this marker stays absent:
-    // the cascade must retain its normal early-publish path.
-    //
-    // seedFirstPush: true — the one cold-open case that DOES publish (a
-    // file that is already broken) sends the complete single diagnostic on
-    // its first push; there is no observed partial-then-complete sequence to
-    // wait out.
-    //
-    // aggregateWaitMs: 2000 covers the measured warm edit-to-publish latency
-    // (~930ms, syntax reparse) with margin; a cold spawn's first push (~2.1s
-    // end-to-end including process start) is bounded separately by
-    // maxClientWaitMs, not this per-diagnostics budget.
-    // intelephense (php, #3310). Measured directly against the real v1.18.5
-    // binary over a raw JSON-RPC session answering `workspace/configuration`
-    // the way pi-lens does (2026-09-23, linux):
-    //
-    //   +284ms  initialize response — NO diagnosticProvider (push-only)
-    //   +295ms  publishDiagnostics diags=0  version=undefined   <- pre-index
-    //   +301ms  indexingStarted
-    //   +689ms  indexingEnded
-    //   +696ms  publishDiagnostics diags=2  version=undefined   <- the answer
-    //
-    // so `emptyFirstPublish: "indexing"`: the first publish is an artifact of
-    // the cold index, not an answer. The same session on a genuinely CLEAN
-    // file publishes `[]` at +304ms and `[]` AGAIN at +663ms (right after
-    // `indexingEnded`), which is what lets the held publish be released by
-    // the server's own second publish instead of by a timer — and a WARM
-    // touch (a second file, index already built) publishes the real set
-    // FIRST at +5ms, so the hold costs nothing once the session is warm.
-    //
-    // seedFirstPush: false — the measurement above is the direct refutation
-    // of "the first push is complete" for this server.
-    // pullRetryBudgetMs: 0 — no pull provider is advertised at all.
-    // aggregateWaitMs: 8000 — the budget must cover the cold index window,
-    // which is what the second (real) publish waits on: ~0.4s for a 139-file
-    // index on the dev box, ~5s on the nightly ubuntu runner (#3217's
-    // transcript). Per-edit callers cap this as a CEILING (#242), so an
-    // interactive edit still waits only its own cap; the uncapped paths (the
-    // tool-smoke LSP gate, which itself caps at 8000ms) get the full budget,
-    // and the cold index is paid once per session, not once per touch.
-    php: {
-        seedFirstPush: false,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 8000,
-        expectSemanticSecondPush: false,
-        emptyFirstPublish: "indexing",
-    },
-    // Svelte's pull diagnostics settle after the default 1500ms budget on a
-    // cold server. The tool-smoke gate caps waits at 8000ms, so give this
-    // server enough aggregate budget to return its seeded findings (#3311).
-    svelte: {
-        seedFirstPush: false,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 4000,
-        expectSemanticSecondPush: false,
-    },
-    // csharp-ls loads (design-time-builds) the restored project AFTER
-    // `initialize` returns, so the publish for a seeded CS0029 lands inside
-    // `waitForDiagnostics`, not inside the client wait. MEASURED A/B over two
-    // nightly Tool-smoke runs of the same fixture with `dotnet restore` already
-    // done — the ONLY difference between them was this budget:
-    //   * `aggregateWaitMs` 1500 (the default): run 36054901266 →
-    //     `[csharp] touched=0`, 4.05s after `Restored …/toolsmoke.csproj`.
-    //     A real compiler error read as clean.
-    //   * 8000: run 36058292424 → `[csharp] touched=1`, 6.49s after the same
-    //     line; gate run 36059988117 → `lsp_diagnostics returned 1 primary
-    //     finding`, 4.86s after it.
-    // Both windows INCLUDE workspace bootstrap + spawn + initialize, so they
-    // bound the wait from above: the required budget is in (1500, 4860] ms.
-    // 6000 covers the measured gate window with margin and stays under the
-    // tool-smoke gate's own 8000ms ceiling (that relation is pinned by
-    // tests/config/lsp-gate-population.test.ts), so the gate can still witness
-    // this budget. CONFIRMED at 6000 by run 36064829436: `✓ csharp csharp-ls 1
-    // lsp_diagnostics returned 1 primary finding`, 4.78s after `Restored
-    // …csproj`, census unchanged at gated 31 / handshake-only 8 / unavailable 6
-    // — so 6000 is measured as sufficient, not merely inferred from the 8000
-    // runs above. It is deliberately NOT the ceiling: an `lsp_diagnostics` call
-    // that passes no `waitMs` pays this budget in full on a file the server never
-    // publishes for (`tools/lsp-diagnostics.ts` leaves `maxClientWaitMs`
-    // undefined → `perServerTimeout` has no caller cap), so every 1000ms here
-    // is 1000ms of turn latency on the no-publication path (#3402 review r2).
-    // Every other field is DEFAULT_STRATEGY's value on purpose: csharp-ls is
-    // `mode=pull`/tier-1 authoritative-clean (#3311 investigator table), and
-    // nothing has measured its pull retry, so this entry moves the one field
-    // that was measured and no other (pinned in
-    // tests/clients/lsp/server-strategies.test.ts).
-    // fsharp/expert/vue deliberately have NO entry: the same two runs show
-    // `touched=0` at BOTH 1500 and 8000, so the budget is not what stops them
-    // publishing and an 8000 entry would buy nothing while costing every
-    // uncapped production call 6.5 extra seconds. Their fixture rows carry the
-    // observed-behavior exemption instead (`scripts/smoke-tools.mjs`), and a
-    // probe that wants a long window sets `PI_LENS_LSP_DIAGNOSTICS_MAX_WAIT_MS`
-    // — a flat harness override that needs no production budget.
-    csharp: {
-        seedFirstPush: false,
-        pullRetryBudgetMs: 250,
-        debounceMs: 150,
-        aggregateWaitMs: 6000,
-        expectSemanticSecondPush: false,
-    },
-    cue: {
-        seedFirstPush: true,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 2000,
-        expectSemanticSecondPush: false,
-        reopenOnResync: false,
-    },
-    // lua-language-server is push-only and was silent on clean transitions in
-    // the repaired probe (run 35914033696). Keep the marker on the measured
-    // server id so the cascade can skip its in-lane wait safely.
-    lua: {
-        seedFirstPush: true,
-        pullRetryBudgetMs: 0,
-        debounceMs: 150,
-        aggregateWaitMs: 2000,
-        expectSemanticSecondPush: false,
-        silentOnClean: true,
-    },
-};
-/** Native TS7 can publish multiple versionless partial-program snapshots for a
- * single open. Its first push is therefore provisional; a quiet window, rather
- * than a protocol-unstable publication count, establishes the settled push. */
-const NATIVE_TS7_DIAGNOSTIC_STRATEGY = {
-    ...SERVER_DIAGNOSTIC_STRATEGIES.typescript,
-    seedFirstPush: false,
-    // Native TS7 demonstrably publishes on clean, so the classic-only marker
-    // must not leak through the shared server id.
-    silentOnClean: false,
-};
-/** Fallback for unknown servers. Conservative defaults. */
-const DEFAULT_STRATEGY = {
-    seedFirstPush: false,
-    pullRetryBudgetMs: 250,
-    debounceMs: 150,
-    aggregateWaitMs: 1500,
-    expectSemanticSecondPush: false,
-};
-export function getStrategy(serverId, launchVariant) {
-    if (serverId === "typescript" && launchVariant === "native-ts7") {
-        return NATIVE_TS7_DIAGNOSTIC_STRATEGY;
-    }
-    return SERVER_DIAGNOSTIC_STRATEGIES[serverId] ?? DEFAULT_STRATEGY;
-}

package/dist/clients/lsp/watch-queue.js

@@ -1,61 +0,0 @@
-/**
- * Debounced `workspace/didChangeWatchedFiles` batching (#271).
- *
- * `handleNotifyOpen` previously sent one `workspace/didChangeWatchedFiles` per
- * file as each was opened. Many servers (TypeScript, …) kick off a project-wide
- * re-analysis on every such notification, so a turn that edits N files in one
- * project triggered ~N full re-analyses. This per-client queue coalesces the
- * changes within a short window and flushes them as a SINGLE notification, so the
- * server re-indexes once per burst instead of once per file.
- *
- * One queue lives per LSP client (= per serverId+root), so batching is naturally
- * scoped to a single server/project. Worst-case added latency before the server
- * learns of a change is the debounce window — negligible against the multi-second
- * re-analysis it gates.
- */
-export const WATCH_DEBOUNCE_MS = 100;
-export class WatchedFilesQueue {
-    flushFn;
-    debounceMs;
-    // uri → latest FileChangeType. A Map collapses repeated events for the same
-    // URI (last-type-wins) while preserving first-seen insertion order.
-    pending = new Map();
-    timer = null;
-    constructor(flushFn, debounceMs = WATCH_DEBOUNCE_MS) {
-        this.flushFn = flushFn;
-        this.debounceMs = debounceMs;
-    }
-    /** Queue a change; arms the debounce timer if not already pending. */
-    enqueue(uri, type) {
-        this.pending.set(uri, type);
-        if (this.timer)
-            return;
-        this.timer = setTimeout(() => this.flush(), this.debounceMs);
-        // Never hold the event loop open for a pending watched-files flush.
-        this.timer.unref?.();
-    }
-    /** Emit all queued changes as one notification (no-op when empty). */
-    flush() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-        if (this.pending.size === 0)
-            return;
-        const changes = [...this.pending.entries()].map(([uri, type]) => ({ uri, type }));
-        this.pending.clear();
-        this.flushFn(changes);
-    }
-    /** Drop the timer + any queued changes without emitting (client teardown). */
-    cancel() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-        this.pending.clear();
-    }
-    /** Number of distinct URIs currently queued (for tests/introspection). */
-    get size() {
-        return this.pending.size;
-    }
-}