lazycodex-ai 5.1.48 → 5.1.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazycodex-ai",
-  "version": "5.1.48",
+  "version": "5.1.51",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -75,6 +75,8 @@
     "packages/omo-codex/plugin/.codex-plugin",
     "packages/omo-codex/marketplace.json",
     "packages/omo-codex/lazycodex-repository",
+    "packages/lsp-core/package.json",
+    "packages/lsp-core/src",
     "packages/lsp-tools-mcp/package.json",
     "packages/lsp-tools-mcp/dist",
     "packages/lsp-daemon/package.json",

package/packages/lsp-core/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@oh-my-opencode/lsp-core",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "description": "Harness-neutral Language Server Protocol engine and tool definitions for oh-my-opencode.",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    },
+    "./tools": {
+      "types": "./src/tools.ts",
+      "import": "./src/tools.ts"
+    },
+    "./request-context": {
+      "types": "./src/request-context.ts",
+      "import": "./src/request-context.ts"
+    },
+    "./missing-dependency-result": {
+      "types": "./src/missing-dependency-result.ts",
+      "import": "./src/missing-dependency-result.ts"
+    },
+    "./mcp": {
+      "types": "./src/mcp.ts",
+      "import": "./src/mcp.ts"
+    },
+    "./post-edit": {
+      "types": "./src/post-edit/index.ts",
+      "import": "./src/post-edit/index.ts"
+    },
+    "./lsp/*": {
+      "types": "./src/lsp/*.ts",
+      "import": "./src/lsp/*.ts"
+    }
+  },
+  "types": "./src/index.ts",
+  "scripts": {
+    "typecheck": "tsgo --noEmit -p tsconfig.json",
+    "test": "bun test src/*.test.ts src/**/*.test.ts"
+  },
+  "dependencies": {
+    "@oh-my-opencode/mcp-stdio-core": "workspace:*"
+  }
+}

package/packages/lsp-core/src/index.ts

@@ -0,0 +1,30 @@
+export * from "./lsp/cleanup-errors.js";
+export * from "./lsp/client-wrapper.js";
+export * from "./lsp/client.js";
+export * from "./lsp/config-loader.js";
+export * from "./lsp/connection.js";
+export * from "./lsp/constants.js";
+export * from "./lsp/directory-diagnostics.js";
+export * from "./lsp/effective-extension.js";
+export * from "./lsp/errors.js";
+export * from "./lsp/format-document.js";
+export * from "./lsp/formatters.js";
+export * from "./lsp/infer-extension.js";
+export * from "./lsp/json-rpc-connection.js";
+export * from "./lsp/language-mappings.js";
+export * from "./lsp/manager.js";
+export * from "./lsp/process-signal-cleanup.js";
+export * from "./lsp/process.js";
+export * from "./lsp/server-definitions.js";
+export * from "./lsp/server-install-state.js";
+export * from "./lsp/server-installation.js";
+export * from "./lsp/server-resolution.js";
+export * from "./lsp/transport.js";
+export * from "./lsp/types.js";
+export * from "./lsp/utils.js";
+export * from "./lsp/workspace-edit.js";
+export * from "./mcp.js";
+export * from "./missing-dependency-result.js";
+export * from "./post-edit/index.js";
+export * from "./request-context.js";
+export * from "./tools.js";

package/packages/lsp-core/src/lsp/bun-command-output.ts

@@ -0,0 +1,82 @@
+import { resolve } from "node:path";
+import type { Diagnostic } from "./types.js";
+
+export interface FileDiagnostic {
+	readonly file: string;
+	readonly diagnostic: Diagnostic;
+}
+
+const TSC_LINE = /^(.+?)\((\d+),(\d+)\): (error|warning|message) (TS\d+): (.*)$/;
+const TSC_SEVERITY: Record<string, number> = { error: 1, warning: 2, message: 3 };
+
+export function parseBunCheckOutput(stdout: string, cwd: string): FileDiagnostic[] {
+	const results: Array<{ file: string; diagnostic: Diagnostic }> = [];
+	for (const line of stdout.split(/\r?\n/)) {
+		const match = TSC_LINE.exec(line);
+		if (match) {
+			const [, path, lineNumber, column, severity, code, message] = match;
+			const start = { line: Number(lineNumber) - 1, character: Number(column) - 1 };
+			results.push({
+				file: resolve(cwd, path ?? ""),
+				diagnostic: {
+					range: { start, end: start },
+					severity: TSC_SEVERITY[severity ?? "error"] ?? 1,
+					code: code ?? "",
+					source: "bun check",
+					message: message ?? "",
+				},
+			});
+			continue;
+		}
+		const previous = results[results.length - 1];
+		if (previous !== undefined && /^\s+\S/.test(line)) {
+			previous.diagnostic.message = `${previous.diagnostic.message}\n${line.trim()}`;
+		}
+	}
+	return results;
+}
+
+interface EslintJsonMessage {
+	readonly ruleId?: string | null;
+	readonly severity?: number;
+	readonly message?: string;
+	readonly line?: number;
+	readonly column?: number;
+	readonly endLine?: number;
+	readonly endColumn?: number;
+}
+
+export function parseBunLintJson(stdout: string): FileDiagnostic[] | undefined {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		return undefined;
+	}
+	if (!Array.isArray(parsed)) return undefined;
+	const results: FileDiagnostic[] = [];
+	for (const entry of parsed) {
+		if (entry === null || typeof entry !== "object") continue;
+		const filePath = (entry as { filePath?: unknown }).filePath;
+		const messages = (entry as { messages?: unknown }).messages;
+		if (typeof filePath !== "string" || !Array.isArray(messages)) continue;
+		for (const raw of messages as EslintJsonMessage[]) {
+			const start = { line: Math.max(0, (raw.line ?? 1) - 1), character: Math.max(0, (raw.column ?? 1) - 1) };
+			const end = {
+				line: raw.endLine === undefined ? start.line : Math.max(0, raw.endLine - 1),
+				character: raw.endColumn === undefined ? start.character : Math.max(0, raw.endColumn - 1),
+			};
+			results.push({
+				file: filePath,
+				diagnostic: {
+					range: { start, end },
+					severity: raw.severity === 2 ? 1 : 2,
+					...(raw.ruleId ? { code: raw.ruleId } : {}),
+					source: "bun lint",
+					message: raw.message ?? "",
+				},
+			});
+		}
+	}
+	return results;
+}

package/packages/lsp-core/src/lsp/bun-project-checks.test.ts

@@ -0,0 +1,170 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parseBunCheckOutput, parseBunLintJson } from "./bun-command-output.js";
+import {
+	__resetBunCommandProbeCacheForTests,
+	bunHasCommand,
+	findBunProjectRoot,
+	projectShadowsBunCommand,
+	resolveBunProjectCommand,
+} from "./bun-project-checks.js";
+import { createFakeBun, createProject, removeFakeBunFixtures } from "./fake-bun-test-support.js";
+
+afterEach(() => {
+	__resetBunCommandProbeCacheForTests();
+	removeFakeBunFixtures();
+});
+
+describe("findBunProjectRoot", () => {
+	it("#given a bun.lock, a bunfig.toml or a bun packageManager #when looked up from a nested directory #then that project root is found", () => {
+		for (const marker of [{ "bun.lock": "" }, { "bunfig.toml": "" }, { "package.json": '{"packageManager":"bun@1.4.3"}' }]) {
+			const root = createProject({ ...marker, "src/deep/a.ts": "" });
+			expect(findBunProjectRoot(join(root, "src", "deep"))).toBe(root);
+		}
+	});
+
+	it("#given an npm project inside a repository #when looked up #then the walk stops at the repository boundary", () => {
+		const root = createProject({ "package.json": '{"packageManager":"npm@11.0.0"}', "package-lock.json": "{}", "src/a.ts": "" });
+		expect(findBunProjectRoot(join(root, "src"))).toBeUndefined();
+	});
+
+	it("#given a bunfig.toml in the home directory and no repository #when looked up below home #then it is not a Bun project", () => {
+		const home = createProject({ "bunfig.toml": "", "work/src/a.ts": "" }, { git: false });
+		expect(findBunProjectRoot(join(home, "work", "src"), home)).toBeUndefined();
+	});
+});
+
+describe("projectShadowsBunCommand", () => {
+	it("#given a package.json script named like the command #when checked #then the built-in command is shadowed", () => {
+		const root = createProject({ "bun.lock": "", "package.json": '{"scripts":{"check":"tsc","lint":"eslint ."}}' });
+		expect(projectShadowsBunCommand("check", root)).toBe(true);
+		expect(projectShadowsBunCommand("lint", root)).toBe(true);
+		expect(projectShadowsBunCommand("format", root)).toBe(false);
+	});
+
+	it("#given a lint.ts file #when checked #then lint is shadowed but check is not", () => {
+		const root = createProject({ "bun.lock": "", "lint.ts": "", "check.ts": "" });
+		expect(projectShadowsBunCommand("lint", root)).toBe(true);
+		expect(projectShadowsBunCommand("check", root)).toBe(false);
+	});
+
+	it("#given a plain lint/ or format/ folder #when checked #then it does not shadow, but one with an index file does", () => {
+		const plain = createProject({ "bun.lock": "", "lint/rules.md": "", "format/notes.txt": "" });
+		expect(projectShadowsBunCommand("lint", plain)).toBe(false);
+		expect(projectShadowsBunCommand("format", plain)).toBe(false);
+		const runnable = createProject({ "bun.lock": "", "lint/index.ts": "" });
+		expect(projectShadowsBunCommand("lint", runnable)).toBe(true);
+	});
+});
+
+describe("bunHasCommand", () => {
+	it("#given a bun without lint #when probed #then only the commands whose --help exits 0 are available", async () => {
+		const bun = createFakeBun({ commands: ["check"] });
+		expect(await bunHasCommand(bun.path, "check")).toBe(true);
+		expect(await bunHasCommand(bun.path, "lint")).toBe(false);
+		expect(await bunHasCommand(bun.path, "format")).toBe(false);
+	});
+
+	it("#given concurrent and repeated probes #when probed #then each command runs --help once, in an empty directory", async () => {
+		const bun = createFakeBun({ commands: ["check", "lint"] });
+		await Promise.all([bunHasCommand(bun.path, "lint"), bunHasCommand(bun.path, "lint")]);
+		await bunHasCommand(bun.path, "lint");
+		const calls = bun.calls();
+		expect(calls.map((call) => call.args)).toEqual([["lint", "--help"]]);
+		expect(calls[0]?.cwdEntries).toEqual([]);
+	});
+
+	it("#given a bun whose format answers --help #when its format --write leaves the file unchanged #then format counts as unavailable", async () => {
+		const silent = createFakeBun({ commands: ["check", "format"], formatWrites: false });
+		const writing = createFakeBun({ commands: ["check", "format"], formatWrites: true });
+		expect(await bunHasCommand(silent.path, "format")).toBe(false);
+		expect(await bunHasCommand(writing.path, "format")).toBe(true);
+		expect(writing.calls().map((call) => call.args)).toEqual([
+			["format", "--help"],
+			["format", "--write", "probe.ts"],
+		]);
+	});
+
+	it("#given a probe that times out #when probed again #then the timeout is not cached as absent and the retry answers", async () => {
+		const release = join(createProject({}), "release");
+		const bun = createFakeBun({ commands: ["check", "lint"], hangHelpUntil: release });
+		expect(await bunHasCommand(bun.path, "lint", 500)).toBe(false);
+		writeFileSync(release, "");
+		expect(await bunHasCommand(bun.path, "lint")).toBe(true);
+	}, 30_000);
+
+	it("#given a bun wrapper that starts bun as a child #when the probe times out #then the probe settles near its deadline", async () => {
+		const release = join(createProject({}), "release");
+		const bun = createFakeBun({ commands: ["check", "lint"], hangHelpUntil: release, wrapperForks: true });
+		const started = performance.now();
+		expect(await bunHasCommand(bun.path, "lint", 500)).toBe(false);
+		expect(performance.now() - started).toBeLessThan(5_000);
+		writeFileSync(release, "");
+	}, 30_000);
+
+	it("#given the bun binary is replaced in place #when probed again #then the new binary is probed", async () => {
+		const bun = createFakeBun({ commands: ["check"] });
+		expect(await bunHasCommand(bun.path, "lint")).toBe(false);
+		bun.upgrade({ commands: ["check", "lint"] });
+		expect(await bunHasCommand(bun.path, "lint")).toBe(true);
+	});
+});
+
+describe("resolveBunProjectCommand", () => {
+	it("#given a non-Bun project #when resolved #then bun is never looked up", async () => {
+		const root = createProject({ "package.json": "{}", "src/a.ts": "" });
+		let lookups = 0;
+		expect(await resolveBunProjectCommand("check", root, { resolveBun: () => (lookups++, "/unused/bun") })).toBeUndefined();
+		expect(lookups).toBe(0);
+	});
+
+	it("#given a Bun project and a bun with check #when resolved #then that bun is returned", async () => {
+		const root = createProject({ "bun.lock": "" });
+		const bun = createFakeBun({ commands: ["check"] });
+		expect(await resolveBunProjectCommand("check", root, { resolveBun: () => bun.path })).toBe(bun.path);
+		expect(await resolveBunProjectCommand("lint", root, { resolveBun: () => bun.path })).toBeUndefined();
+	});
+});
+
+describe("bun command output", () => {
+	it("#given tsc-style bun check output #when parsed #then diagnostics carry file, 0-based position, code and continuation lines", () => {
+		const cwd = createProject({});
+		const parsed = parseBunCheckOutput(
+			"src/x.ts(3,7): error TS2322: Type 'string' is not assignable to type 'number'.\n  The expected type comes from here.\n",
+			cwd,
+		);
+		expect(parsed).toEqual([
+			{
+				file: join(cwd, "src", "x.ts"),
+				diagnostic: {
+					range: { start: { line: 2, character: 6 }, end: { line: 2, character: 6 } },
+					severity: 1,
+					code: "TS2322",
+					source: "bun check",
+					message: "Type 'string' is not assignable to type 'number'.\nThe expected type comes from here.",
+				},
+			},
+		]);
+	});
+
+	it("#given ESLint JSON from bun lint #when parsed #then errors and warnings map to LSP severities", () => {
+		const parsed = parseBunLintJson(
+			JSON.stringify([
+				{
+					filePath: "/p/a.ts",
+					messages: [
+						{ ruleId: "prefer-const", severity: 2, message: "Use const", line: 3, column: 7, endLine: 3, endColumn: 12 },
+						{ ruleId: null, severity: 1, message: "Unused directive", line: 1, column: 1 },
+					],
+				},
+			]),
+		);
+		expect(parsed?.map(({ file, diagnostic }) => [file, diagnostic.severity, diagnostic.code, diagnostic.range.start])).toEqual([
+			["/p/a.ts", 1, "prefer-const", { line: 2, character: 6 }],
+			["/p/a.ts", 2, undefined, { line: 0, character: 0 }],
+		]);
+		expect(parseBunLintJson("not json")).toBeUndefined();
+	});
+});

package/packages/lsp-core/src/lsp/bun-project-checks.ts

@@ -0,0 +1,223 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createSpawnCommand, killProcessTree } from "./process.js";
+import { resolveServerBinary } from "./server-installation.js";
+
+export type BunProjectCommand = "check" | "lint" | "format";
+
+export interface BunProjectChecksOptions {
+	readonly resolveBun?: (cwd: string) => string | null;
+	readonly homeDir?: string;
+}
+
+export interface BunCommandRun {
+	readonly exitCode: number | null;
+	readonly stdout: string;
+	readonly stderr: string;
+}
+
+const BUN_LOCKFILES = ["bun.lock", "bun.lockb", "bunfig.toml"];
+const RUNNABLE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".cts", ".cjs", ".js", ".mjs", ".mts"];
+const BIN_SUFFIXES = process.platform === "win32" ? [".exe", ".bunx", ".cmd", ""] : [""];
+const PROBE_TIMEOUT_MS = 10_000;
+const UNFORMATTED_PROBE = "const a=1\n";
+
+const probeCache = new Map<string, Promise<boolean>>();
+
+export function __resetBunCommandProbeCacheForTests(): void {
+	probeCache.clear();
+}
+
+// The walk stops at the repository boundary, and never reads the home directory or anything above
+// it, so a stray file there does not turn every directory outside a repository into a Bun project.
+export function findBunProjectRoot(start: string, home: string = homedir()): string | undefined {
+	const stopAt = resolve(home);
+	let dir = resolve(start);
+	for (;;) {
+		if (dir === stopAt) return undefined;
+		if (BUN_LOCKFILES.some((name) => existsSync(join(dir, name)))) return dir;
+		if (packageManagerIsBun(join(dir, "package.json"))) return dir;
+		if (existsSync(join(dir, ".git"))) return undefined;
+		const parent = dirname(dir);
+		if (parent === dir) return undefined;
+		dir = parent;
+	}
+}
+
+function packageManagerIsBun(packageJsonPath: string): boolean {
+	const manifest = readJsonObject(packageJsonPath);
+	const packageManager = manifest?.["packageManager"];
+	return typeof packageManager === "string" && packageManager.startsWith("bun@");
+}
+
+function readJsonObject(path: string): Record<string, unknown> | undefined {
+	if (!existsSync(path)) return undefined;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+			? (parsed as Record<string, unknown>)
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isFile(path: string): boolean {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+
+function isDirectory(path: string): boolean {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+// Bun still runs a project's own script (nearest package.json) named check/lint/format, and for
+// lint/format also what `bun <name>` would run as a file: `name` or `name.<ext>`, a `name/` directory
+// with a package.json or an index file, or an executable a package installed in node_modules/.bin.
+export function projectShadowsBunCommand(command: BunProjectCommand, cwd: string): boolean {
+	const packageJsonDir = nearestPackageJsonDir(cwd);
+	if (packageJsonDir !== undefined) {
+		const scripts = readJsonObject(join(packageJsonDir, "package.json"))?.["scripts"];
+		if (scripts !== null && typeof scripts === "object" && typeof (scripts as Record<string, unknown>)[command] === "string") {
+			return true;
+		}
+	}
+	if (command === "check") return false;
+	const base = join(cwd, command);
+	if (isFile(base) || RUNNABLE_EXTENSIONS.some((extension) => isFile(`${base}${extension}`))) return true;
+	if (isDirectory(base) && (isFile(join(base, "package.json")) || RUNNABLE_EXTENSIONS.some((extension) => isFile(join(base, `index${extension}`))))) {
+		return true;
+	}
+	let dir = resolve(cwd);
+	for (;;) {
+		if (BIN_SUFFIXES.some((suffix) => existsSync(join(dir, "node_modules", ".bin", `${command}${suffix}`)))) return true;
+		const parent = dirname(dir);
+		if (parent === dir) return false;
+		dir = parent;
+	}
+}
+
+function nearestPackageJsonDir(start: string): string | undefined {
+	let dir = resolve(start);
+	for (;;) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return undefined;
+		dir = parent;
+	}
+}
+
+function binaryIdentity(bunPath: string): string {
+	try {
+		const stats = statSync(bunPath);
+		return `${stats.mtimeMs}:${stats.size}`;
+	} catch {
+		return "missing";
+	}
+}
+
+// Feature detection by exit code, in an empty directory: next to a same-named project script an
+// older Bun runs that script for `--help` and exits 0. Asynchronous, so a probe never blocks the
+// event loop; cached per binary and command, and re-probed when the binary file changes. Only a
+// definite answer is kept: a probe that timed out or could not spawn is retried on the next call.
+export function bunHasCommand(
+	bunPath: string,
+	command: BunProjectCommand,
+	timeoutMs: number = PROBE_TIMEOUT_MS,
+): Promise<boolean> {
+	const key = `${bunPath}\0${binaryIdentity(bunPath)}\0${command}`;
+	const cached = probeCache.get(key);
+	if (cached !== undefined) return cached;
+	const probe = probeOnce(bunPath, command, timeoutMs).then((answer) => {
+		if (answer === undefined) probeCache.delete(key);
+		return answer === true;
+	});
+	probeCache.set(key, probe);
+	return probe;
+}
+
+// `format` must also prove it rewrites a file in place: a bun whose `format --write` printed to stdout
+// instead, or ignored the flag, would leave every file unchanged and silently stop formatting.
+async function probeOnce(bunPath: string, command: BunProjectCommand, timeoutMs: number): Promise<boolean | undefined> {
+	const emptyDir = mkdtempSync(join(tmpdir(), "omo-bun-probe-"));
+	const timeout = AbortSignal.timeout(timeoutMs);
+	try {
+		const help = await runBunCommand(bunPath, [command, "--help"], emptyDir, timeout);
+		if (help.exitCode === null) return undefined;
+		if (help.exitCode !== 0) return false;
+		if (command !== "format") return true;
+		const probeFile = join(emptyDir, "probe.ts");
+		writeFileSync(probeFile, UNFORMATTED_PROBE);
+		const write = await runBunCommand(bunPath, ["format", "--write", "probe.ts"], emptyDir, timeout);
+		if (write.exitCode === null) return undefined;
+		return write.exitCode === 0 && readFileSync(probeFile, "utf8") !== UNFORMATTED_PROBE;
+	} catch {
+		return undefined;
+	} finally {
+		rmSync(emptyDir, { recursive: true, force: true });
+	}
+}
+
+export async function resolveBunProjectCommand(
+	command: BunProjectCommand,
+	cwd: string,
+	options: BunProjectChecksOptions = {},
+): Promise<string | undefined> {
+	if (findBunProjectRoot(cwd, options.homeDir) === undefined) return undefined;
+	if (projectShadowsBunCommand(command, cwd)) return undefined;
+	const bunPath = (options.resolveBun ?? defaultResolveBun)(cwd);
+	if (!bunPath) return undefined;
+	return (await bunHasCommand(bunPath, command)) ? bunPath : undefined;
+}
+
+function defaultResolveBun(cwd: string): string | null {
+	return resolveServerBinary(["bun"], cwd);
+}
+
+export function runBunCommand(bunPath: string, args: readonly string[], cwd: string, signal?: AbortSignal): Promise<BunCommandRun> {
+	signal?.throwIfAborted();
+	const prepared = createSpawnCommand([bunPath, ...args]);
+	return new Promise((resolvePromise, reject) => {
+		const child = spawn(prepared.command, prepared.args, {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			shell: prepared.shell,
+			windowsHide: true,
+			detached: process.platform !== "win32",
+		});
+		const stdout: Buffer[] = [];
+		const stderr: Buffer[] = [];
+		// A wrapper (a .cmd shim through cmd.exe on Windows, a non-exec sh script elsewhere) leaves bun holding
+		// the pipes when only the direct child dies, so an aborted probe would outlive its timeout. Kill the
+		// whole tree: taskkill /T on Windows, the process group (hence `detached`) elsewhere.
+		const onAbort = () => killProcessTree(child, "SIGKILL");
+		signal?.addEventListener("abort", onAbort, { once: true });
+		child.stdout?.on("data", (chunk: Buffer) => stdout.push(chunk));
+		child.stderr?.on("data", (chunk: Buffer) => stderr.push(chunk));
+		child.once("error", (error) => {
+			signal?.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+		child.once("close", (exitCode) => {
+			signal?.removeEventListener("abort", onAbort);
+			if (signal?.aborted) {
+				reject(signal.reason);
+				return;
+			}
+			resolvePromise({
+				exitCode,
+				stdout: Buffer.concat(stdout).toString("utf8"),
+				stderr: Buffer.concat(stderr).toString("utf8"),
+			});
+		});
+	});
+}

package/packages/lsp-core/src/lsp/cleanup-errors.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test";
+
+import { reportBestEffortCleanupError } from "./cleanup-errors.js";
+
+describe("reportBestEffortCleanupError", () => {
+	test("#given an injected cleanup logger #when cleanup fails #then the normal diagnostic is emitted without an environment gate", () => {
+		// given
+		const messages: string[] = [];
+
+		// when
+		reportBestEffortCleanupError("client stop", new Error("connection closed"), (message) => {
+			messages.push(message);
+		});
+
+		// then
+		expect(messages).toEqual(["[lsp] ignored client stop failure during cleanup: connection closed"]);
+	});
+});

package/packages/lsp-core/src/lsp/cleanup-errors.ts

@@ -0,0 +1,14 @@
+export type CleanupErrorLogger = (message: string) => void;
+
+function writeCleanupError(message: string): void {
+	process.stderr.write(`${message}\n`);
+}
+
+export function reportBestEffortCleanupError(
+	operation: string,
+	error: unknown,
+	logger: CleanupErrorLogger = writeCleanupError,
+): void {
+	const message = error instanceof Error ? error.message : String(error);
+	logger(`[lsp] ignored ${operation} failure during cleanup: ${message}`);
+}

package/packages/lsp-core/src/lsp/client-diagnostics-concurrency.integration.test.ts

@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { ControlledClock } from "./controlled-clock-test-support.js";
+
+import {
+	createWorkspaceEditTestHarness,
+	diagnostic,
+	readEvents,
+} from "./workspace-apply-edit-test-support.js";
+
+const harness = createWorkspaceEditTestHarness();
+
+afterEach(async () => {
+	await harness.cleanup();
+});
+
+describe("LspClient diagnostics concurrency", () => {
+	it("#given concurrent diagnostics on a cold file and an exact didOpen publish #when pull is not advertised #then one didOpen opens the file and both requests receive the current diagnostics", async () => {
+		// The freshness window runs on a controlled clock: this case asserts that the exact-version
+		// didOpen publish satisfies BOTH requests, and the publish is what wakes them. On a real clock
+		// the 500ms window is a second, competing deadline against a real fixture server over a real
+		// pipe, so a starved Windows shard resolved the requests clean before the publish landed and
+		// the case failed with [] (#8323). Frozen, only the publish can settle it.
+		const clock = new ControlledClock();
+		const context = await harness.makeClient(
+			{
+				publishDiagnostics: [
+					{
+						trigger: "didOpen",
+						version: 1,
+						diagnostics: [diagnostic("exact-current")],
+						awaitClientDelivery: true,
+					},
+				],
+			},
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
+		);
+
+		const [first, second] = await Promise.all([
+			context.client.diagnostics(context.source),
+			context.client.diagnostics(context.source),
+		]);
+
+		expect(first.items).toEqual([diagnostic("exact-current")]);
+		expect(second.items).toEqual([diagnostic("exact-current")]);
+		expect(
+			readEvents(context.events).filter(
+				(event) => event.type === "clientNotification" && event.method === "textDocument/didOpen",
+			),
+		).toHaveLength(1);
+	});
+});