oh-my-opencode 5.0.0-beta.25 → 5.0.0-beta.28

package/dist/tui.js

@@ -17499,6 +17499,25 @@ var init_telemetry = __esm(() => {
   }).strict();
 });
 
+// packages/omo-config-core/src/schema/format-on-mutation.ts
+var mode, languages, OmoFormatOnMutationLayerSchema, OmoFormatOnMutationSchema;
+var init_format_on_mutation = __esm(() => {
+  init_zod();
+  mode = _enum2(["off", "best-effort", "required"]);
+  languages = record(string2(), boolean2()).optional();
+  OmoFormatOnMutationLayerSchema = object({
+    mode: mode.optional(),
+    languages,
+    maxFileBytes: number2().int().positive().optional(),
+    timeoutMs: number2().int().positive().optional()
+  }).strict();
+  OmoFormatOnMutationSchema = OmoFormatOnMutationLayerSchema.extend({
+    mode: mode.default("best-effort"),
+    maxFileBytes: number2().int().positive().default(1048576),
+    timeoutMs: number2().int().positive().default(3000)
+  }).strict();
+});
+
 // packages/omo-config-core/src/schema/config.ts
 var OmoOpenCodeHarnessConfigSchema, OmoTypedHarnessConfigSchema, OmoConfigProfileSchema, OmoConfigSchema, OmoConfigLayerSchema;
 var init_config = __esm(() => {
@@ -17512,8 +17531,10 @@ var init_config = __esm(() => {
   init_task();
   init_team();
   init_telemetry();
+  init_format_on_mutation();
   OmoOpenCodeHarnessConfigSchema = record(string2(), unknown());
   OmoTypedHarnessConfigSchema = object({
+    formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
     codegraph: OmoCodegraphSettingsLayerSchema.optional(),
@@ -17525,6 +17546,7 @@ var init_config = __esm(() => {
     telemetry: OmoTelemetrySettingsLayerSchema.optional()
   }).strict();
   OmoConfigProfileSchema = object({
+    formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
     codegraph: OmoCodegraphSettingsLayerSchema.optional(),
@@ -17539,6 +17561,7 @@ var init_config = __esm(() => {
     "[codex]": OmoTypedHarnessConfigSchema.optional()
   }).strict();
   OmoConfigSchema = object({
+    formatOnMutation: OmoFormatOnMutationSchema.optional(),
     $schema: string2().optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
@@ -17557,6 +17580,7 @@ var init_config = __esm(() => {
     legacy_migrations: record(string2(), unknown()).optional()
   }).strict();
   OmoConfigLayerSchema = object({
+    formatOnMutation: OmoFormatOnMutationLayerSchema.optional(),
     $schema: string2().optional(),
     categories: OmoCategoriesConfigSchema.optional(),
     agents: OmoAgentsConfigSchema.optional(),
@@ -17583,6 +17607,7 @@ var init_schema = __esm(() => {
   init_codegraph();
   init_config();
   init_fallback_models();
+  init_format_on_mutation();
   init_git_master();
   init_harness();
   init_memory();
@@ -18651,6 +18676,9 @@ var init_message_inspection_error = () => {};
 function getPromptGateMessagesFetchTimeoutMs() {
   return promptGateMessagesFetchTimeoutMsForTesting ?? DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS;
 }
+function getPromptGateRevalidationTimeoutMs() {
+  return promptGateRevalidationTimeoutMsForTesting ?? DEFAULT_PROMPT_REVALIDATION_TIMEOUT_MS;
+}
 async function withDispatchTimeout(operation, dispatchTimeoutMs, operationName) {
   if (dispatchTimeoutMs <= 0) {
     return operation;
@@ -18669,7 +18697,7 @@ async function withDispatchTimeout(operation, dispatchTimeoutMs, operationName)
     }
   }
 }
-var DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, promptGateMessagesFetchTimeoutMsForTesting;
+var DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, DEFAULT_PROMPT_REVALIDATION_TIMEOUT_MS = 5000, promptGateMessagesFetchTimeoutMsForTesting, promptGateRevalidationTimeoutMsForTesting;
 
 // packages/utils/src/prompt-async-gate/pending-tool-turn.ts
 function getPromptQuery(input) {
@@ -18866,6 +18894,7 @@ async function dispatchAfterSessionIdle(args) {
     checkStatus,
     checkToolState,
     shouldDispatch,
+    retryDispatchFailure,
     dispatch
   } = args;
   const existing = getActiveReservation(sessionID);
@@ -18920,7 +18949,9 @@ async function dispatchAfterSessionIdle(args) {
       });
       return { status: "active" };
     }
-    if (shouldDispatch?.() === false) {
+    const dispatchDecision = shouldDispatch?.();
+    const resolvedDispatchDecision = dispatchDecision !== undefined && typeof dispatchDecision !== "boolean" ? await withDispatchTimeout(dispatchDecision, Math.min(dispatchTimeoutMs, getPromptGateRevalidationTimeoutMs()), `[prompt-async-gate] ${sessionName} shouldDispatch`) : dispatchDecision;
+    if (resolvedDispatchDecision === false) {
       log(`[prompt-async-gate] ${sessionName} cancelled before dispatch`, { sessionID, source });
       return { status: "cancelled" };
     }
@@ -18936,6 +18967,7 @@ async function dispatchAfterSessionIdle(args) {
     log(`[prompt-async-gate] ${sessionName} dispatched`, { sessionID, source });
     return { status: "dispatched", response };
   } catch (error51) {
+    const queueRetryable = dispatchAttempted && retryDispatchFailure?.(error51) === true;
     if (dispatchAttempted) {
       rememberRecentPromptDispatch({
         sessionID,
@@ -18946,7 +18978,12 @@ async function dispatchAfterSessionIdle(args) {
     }
     const errorText = error51 instanceof Error ? `${error51.name}: ${error51.message}` : String(error51);
     log(`[prompt-async-gate] ${sessionName} failed`, { sessionID, source, error: errorText });
-    return { status: "failed", error: error51, dispatchAttempted };
+    return {
+      status: "failed",
+      error: error51,
+      dispatchAttempted,
+      ...queueRetryable ? { queueRetryable: true } : {}
+    };
   } finally {
     finishPromptReservation(sessionID, reservation, dispatchAttempted, postDispatchHoldMs);
   }
@@ -18999,6 +19036,7 @@ function schedulePromptQueueDrain(sessionID, delayMs) {
   promptQueueTimers.set(sessionID, timer);
 }
 function removePromptQueueEntry(sessionID, entry) {
+  promptQueueRetryStates.delete(entry.id);
   const queue = promptQueues.get(sessionID);
   if (!queue) {
     return;
@@ -19013,6 +19051,7 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
   promptQueueDraining.add(sessionID);
   clearPromptQueueTimer(sessionID);
   let awaitedResult;
+  const deferredRetryIds = new Set;
   try {
     while (true) {
       const queue = promptQueues.get(sessionID);
@@ -19020,6 +19059,20 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
       if (!entry) {
         break;
       }
+      const retryState = promptQueueRetryStates.get(entry.id);
+      if (entry.durableRetry && retryState?.retryAfter !== undefined && retryState.retryAfter > Date.now()) {
+        if (deferredRetryIds.has(entry.id)) {
+          const nextRetryAt = Math.min(...queue.flatMap((queued) => {
+            const retryAfter = promptQueueRetryStates.get(queued.id)?.retryAfter;
+            return retryAfter === undefined ? [] : [retryAfter];
+          }));
+          schedulePromptQueueDrain(sessionID, nextRetryAt - Date.now());
+          break;
+        }
+        deferredRetryIds.add(entry.id);
+        setPromptQueue(sessionID, [...queue.slice(1), entry]);
+        continue;
+      }
       promptQueueInFlight.set(sessionID, entry);
       const result = await dispatchAfterSessionIdle({
         sessionName: entry.sessionName,
@@ -19035,12 +19088,45 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
         checkStatus: entry.checkStatus,
         checkToolState: entry.checkToolState,
         shouldDispatch: entry.shouldDispatch,
+        retryDispatchFailure: entry.retryDispatchFailure,
         dispatch: entry.dispatch
       });
       if (promptQueueInFlight.get(sessionID)?.id === entry.id) {
         promptQueueInFlight.delete(sessionID);
       }
-      if (result.status === "active" || result.status === "reserved") {
+      const retryableQueuedFailure = result.status === "failed" && (!result.dispatchAttempted || result.queueRetryable === true);
+      if (retryableQueuedFailure) {
+        const failureCount = (promptQueueRetryStates.get(entry.id)?.failureCount ?? 0) + 1;
+        if (entry.durableRetry) {
+          const exponentialBackoffMs = entry.queueRetryMs * 2 ** Math.min(failureCount, 7);
+          const retryDelayMs = Math.max(entry.postDispatchHoldMs, Math.min(exponentialBackoffMs, MAX_DURABLE_RETRY_BACKOFF_MS));
+          promptQueueRetryStates.set(entry.id, {
+            failureCount,
+            retryAfter: Date.now() + retryDelayMs
+          });
+          const currentQueue = promptQueues.get(sessionID);
+          if (currentQueue && currentQueue.length > 1) {
+            setPromptQueue(sessionID, [...currentQueue.slice(1), entry]);
+            continue;
+          }
+          schedulePromptQueueDrain(sessionID, retryDelayMs);
+          break;
+        }
+        if (failureCount >= MAX_QUEUED_RETRYABLE_FAILURES) {
+          log("[prompt-async-gate] dropping queued prompt after repeated retryable failures", {
+            sessionID,
+            source: entry.source,
+            failureCount
+          });
+          removePromptQueueEntry(sessionID, entry);
+          if (awaitedEntry?.id === entry.id) {
+            awaitedResult = result;
+          }
+          continue;
+        }
+        promptQueueRetryStates.set(entry.id, { failureCount });
+      }
+      if (result.status === "active" || result.status === "reserved" || retryableQueuedFailure) {
         const queued = queuedResult(entry, 1, result.status === "reserved" ? result.reservedBy : entry.source);
         if (awaitedEntry?.id === entry.id) {
           awaitedResult = queued;
@@ -19064,7 +19150,7 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
   }
   return awaitedResult;
 }
-var promptQueues, promptQueueDraining, promptQueueInFlight, promptQueueTimers;
+var promptQueues, promptQueueDraining, promptQueueInFlight, promptQueueTimers, promptQueueRetryStates, MAX_QUEUED_RETRYABLE_FAILURES = 3, MAX_DURABLE_RETRY_BACKOFF_MS = 30000;
 var init_queue = __esm(() => {
   init_session_idle_dispatch();
   init_reservations();
@@ -19072,6 +19158,7 @@ var init_queue = __esm(() => {
   promptQueueDraining = new Set;
   promptQueueInFlight = new Map;
   promptQueueTimers = new Map;
+  promptQueueRetryStates = new Map;
   setExpiredReservationHandler((sessionID) => {
     schedulePromptQueueDrain(sessionID, 0);
   });
@@ -78070,7 +78157,17 @@ function isPreSendConnectionFailure(error51) {
   if (error51.name === "AbortError") {
     return false;
   }
-  const CONNECTION_CODES = new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN"]);
+  const CONNECTION_CODES = new Set([
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "ENETUNREACH",
+    "EHOSTUNREACH",
+    "ENETDOWN",
+    "EHOSTDOWN",
+    "EADDRNOTAVAIL",
+    "UND_ERR_CONNECT_TIMEOUT"
+  ]);
   const self = error51;
   if (self.code && CONNECTION_CODES.has(self.code)) {
     return true;
@@ -78082,12 +78179,6 @@ function isPreSendConnectionFailure(error51) {
       return true;
     }
   }
-  if (error51 instanceof TypeError) {
-    const msg = error51.message;
-    if (msg.includes("fetch failed") || msg.includes("Unable to connect")) {
-      return true;
-    }
-  }
   return false;
 }
 function markLiveRouteUnavailable(reason) {
@@ -78411,7 +78502,6 @@ var sessionCategoryMap;
 var init_session_category_registry = __esm(() => {
   sessionCategoryMap = new Map;
 });
-
 // packages/omo-opencode/src/shared/legacy-plugin-warning.ts
 var init_legacy_plugin_warning = __esm(() => {
   init_jsonc_parser2();
@@ -81989,7 +82079,7 @@ function registerSidebarContentSlot({
   registerSlot({
     order: 900,
     slots: {
-      sidebar_content: renderSidebar
+      sidebar_content: () => renderSidebar
     }
   });
   requestRender();
@@ -82110,5 +82200,6 @@ var module = {
 var tui_default = module;
 export {
   tui_default as default,
-  handleTuiPollError
+  handleTuiPollError,
+  registerSidebarContentSlot
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "5.0.0-beta.25",
+  "version": "5.0.0-beta.28",
   "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",
@@ -181,7 +181,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@code-yeongyu/senpi": "2026.8.26-2",
+    "@code-yeongyu/senpi": "2026.8.30",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/ast-grep-mcp": "workspace:*",
     "@oh-my-opencode/boulder-state": "workspace:*",
@@ -222,18 +222,18 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "5.0.0-beta.25",
-    "oh-my-opencode-darwin-x64": "5.0.0-beta.25",
-    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.25",
-    "oh-my-opencode-linux-arm64": "5.0.0-beta.25",
-    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.25",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.25",
-    "oh-my-opencode-windows-arm64": "5.0.0-beta.25",
-    "oh-my-opencode-windows-x64": "5.0.0-beta.25",
-    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.25"
+    "oh-my-opencode-darwin-arm64": "5.0.0-beta.28",
+    "oh-my-opencode-darwin-x64": "5.0.0-beta.28",
+    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.28",
+    "oh-my-opencode-linux-arm64": "5.0.0-beta.28",
+    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.28",
+    "oh-my-opencode-linux-x64": "5.0.0-beta.28",
+    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.28",
+    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.28",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.28",
+    "oh-my-opencode-windows-arm64": "5.0.0-beta.28",
+    "oh-my-opencode-windows-x64": "5.0.0-beta.28",
+    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.28"
   },
   "overrides": {
     "@earendil-works/pi-agent-core": "0.84.2",
@@ -249,5 +249,8 @@
   },
   "trustedDependencies": [
     "@code-yeongyu/comment-checker"
-  ]
+  ],
+  "patchedDependencies": {
+    "@code-yeongyu/senpi@2026.8.30": "patches/@code-yeongyu%2Fsenpi@2026.8.30.patch"
+  }
 }

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

@@ -7,6 +7,7 @@ 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";

package/packages/lsp-core/src/lsp/client-wrapper.ts

@@ -17,6 +17,7 @@ import {
 } from "./errors.js";
 import { getLspManager, type LspManager } from "./manager.js";
 import { findWorkspaceRootOutsideContext } from "./outside-context-workspace.js";
+import { LSP_LOCAL_INSTALL_HINTS } from "./server-definitions.js";
 import { loadInstallDecision } from "./server-install-state.js";
 import { findServerForExtension } from "./server-resolution.js";
 import type { ServerLookupResult } from "./types.js";
@@ -138,6 +139,26 @@ export function formatServerLookupError(result: Exclude<ServerLookupResult, { st
 	].join("\n");
 }
 
+/**
+ * Builds the install guidance, offering the repo-local install first.
+ *
+ * A repo-local install is resolvable without touching the global environment, so it is the
+ * recommended route whenever the server ships as a project dependency.
+ */
+function formatInstallOptions(serverId: string, installHint: string): string[] {
+	const localHint = LSP_LOCAL_INSTALL_HINTS[serverId];
+	if (localHint === undefined) {
+		return ["To install, run:", `  ${installHint}`];
+	}
+	return [
+		"To install in THIS repository (preferred — no global install needed):",
+		`  ${localHint}`,
+		"",
+		"Or install it globally:",
+		`  ${installHint}`,
+	];
+}
+
 function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_installed" }>): string {
 	const { server, installHint } = result;
 	const extensions = server.extensions.join(", ");
@@ -154,20 +175,20 @@ function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_i
 		`Command not found: ${server.command[0]}`,
 		"",
 	];
+	const installOptions = formatInstallOptions(server.id, installHint);
 
 	if (decision === "allowed") {
 		return [
 			...header,
 			"The user has pre-authorized LSP installation. Run the install command, then retry this tool:",
-			`  ${installHint}`,
+			...installOptions.slice(1),
 		].join("\n");
 	}
 
 	if (!context.capabilities.installDecisionTool) {
 		return [
 			...header,
-			"To install, run:",
-			`  ${installHint}`,
+			...installOptions,
 			"",
 			"ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
 			"Install-decision recording is unavailable in this harness; proceed without LSP if the user declines.",
@@ -176,8 +197,7 @@ function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_i
 
 	return [
 		...header,
-		"To install, run:",
-		`  ${installHint}`,
+		...installOptions,
 		"",
 		"ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
 		"- If the user agrees: run the install command above, then retry this tool.",

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

@@ -6,6 +6,7 @@ import type { LspClientTimeoutOptions } from "./transport.js";
 import type {
 	Diagnostic,
 	DocumentSymbol,
+	FormattingOptions,
 	Location,
 	LocationLink,
 	PrepareRenameDefaultBehavior,
@@ -13,6 +14,7 @@ import type {
 	Range,
 	ResolvedServer,
 	SymbolInfo,
+	TextEdit,
 	WorkspaceEdit,
 } from "./types.js";
 import { LspRequestTimeoutError } from "./errors.js";
@@ -133,6 +135,30 @@ export class LspClient extends LspClientConnection {
 		}, options);
 	}
 
+	/**
+	 * Requests whole-document formatting edits, returning null when the server never advertised the
+	 * capability so callers can report unavailability instead of surfacing a method-not-found error.
+	 */
+	async formatDocument(
+		filePath: string,
+		options: FormattingOptions,
+		signal?: AbortSignal,
+	): Promise<TextEdit[] | null> {
+		if (!this.isDocumentFormattingSupported()) return null;
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.openFile(absPath);
+		const requestOptions = signal === undefined ? {} : { signal };
+		const edits = await this.sendRequest<TextEdit[] | null>(
+			"textDocument/formatting",
+			{
+				textDocument: { uri: pathToFileURL(absPath).href },
+				options,
+			},
+			requestOptions,
+		);
+		return edits ?? [];
+	}
+
 	async workspaceSymbols(query: string, signal?: AbortSignal): Promise<SymbolInfo[]> {
 		const options = signal === undefined ? {} : { signal };
 		return this.sendRequest<SymbolInfo[]>("workspace/symbol", { query }, options);

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

@@ -4,6 +4,7 @@ import { LspClientTransport } from "./transport.js";
 
 interface InitializeCapabilities {
 	readonly diagnosticProvider?: unknown;
+	readonly documentFormattingProvider?: unknown;
 }
 
 function supportsDiagnosticPull(capabilities: InitializeCapabilities | undefined): boolean {
@@ -11,6 +12,19 @@ function supportsDiagnosticPull(capabilities: InitializeCapabilities | undefined
 	return Object.hasOwn(capabilities, "diagnosticProvider");
 }
 
+/**
+ * Reads the whole-document formatting capability the server advertised at initialize time.
+ *
+ * The provider is either a boolean or an options object, and an explicit `false` means the
+ * server refuses the request, so both shapes are checked instead of mere key presence.
+ */
+function supportsDocumentFormatting(capabilities: InitializeCapabilities | undefined): boolean {
+	if (capabilities === undefined) return false;
+	const provider = capabilities.documentFormattingProvider;
+	if (provider === undefined || provider === null || provider === false) return false;
+	return provider === true || typeof provider === "object";
+}
+
 export class LspClientConnection extends LspClientTransport {
 	async initialize(): Promise<void> {
 		const rootUri = pathToFileURL(this.root).href;
@@ -28,6 +42,7 @@ export class LspClientConnection extends LspClientTransport {
 						references: {},
 						documentSymbol: { hierarchicalDocumentSymbolSupport: true },
 						publishDiagnostics: {},
+						formatting: { dynamicRegistration: false },
 						rename: {
 							prepareSupport: true,
 							prepareSupportDefaultBehavior: 1,
@@ -71,6 +86,7 @@ export class LspClientConnection extends LspClientTransport {
 			{ timeoutMs: this.initializeTimeoutMs },
 		);
 		this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
+		this.setDocumentFormattingSupported(supportsDocumentFormatting(result?.capabilities));
 		await this.sendNotification("initialized", {});
 		await this.sendNotification("workspace/didChangeConfiguration", {
 			settings: { json: { validate: { enable: true } } },

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

@@ -6,6 +6,7 @@ export const DEFAULT_MAX_DIRECTORY_FILES = 50;
 export const REQUEST_TIMEOUT_MS = 15_000;
 export const INIT_TIMEOUT_MS = 60_000;
 export const IDLE_TIMEOUT_MS = 5 * 60_000;
+export const MAX_RESIDENT_CLIENTS = 6;
 export const REAPER_INTERVAL_MS = 60_000;
 export const STOP_HARD_KILL_TIMEOUT_MS = 5_000;
 export const STOP_SIGKILL_GRACE_MS = 1_000;

package/packages/lsp-core/src/lsp/format-document.test.ts

@@ -0,0 +1,143 @@
+import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import type { LspClient } from "./client.js";
+import { formatDocumentWithClient } from "./format-document.js";
+import type { TextEdit } from "./types.js";
+
+const workspaces: string[] = [];
+
+afterEach(() => {
+	for (const workspace of workspaces.splice(0)) rmSync(workspace, { recursive: true, force: true });
+});
+
+function workspaceWith(fileName: string, content: string): { readonly root: string; readonly filePath: string } {
+	const root = mkdtempSync(join(tmpdir(), "lsp-format-"));
+	workspaces.push(root);
+	const filePath = join(root, fileName);
+	writeFileSync(filePath, content, "utf-8");
+	return { root, filePath };
+}
+
+function stubClient(edits: TextEdit[] | null): LspClient {
+	return {
+		async formatDocument() {
+			return edits;
+		},
+		async openFile() {},
+	} as Pick<LspClient, "formatDocument" | "openFile"> as LspClient;
+}
+
+describe("formatDocumentWithClient", () => {
+	it("#given a server returning text edits #when the document is formatted #then the file is rewritten and line deltas are reported", async () => {
+		// given
+		const { filePath } = workspaceWith("sample.ts", "const a=1\nconst b   =2\nconst c=3\n");
+		const edits: TextEdit[] = [
+			{ range: { start: { line: 0, character: 0 }, end: { line: 1, character: 12 } }, newText: "const a = 1;\nconst b = 2;" },
+		];
+
+		// when
+		const result = await formatDocumentWithClient(stubClient(edits), filePath);
+
+		// then
+		expect(result.status).toBe("formatted");
+		expect(readFileSync(filePath, "utf-8")).toBe("const a = 1;\nconst b = 2;\nconst c=3\n");
+		expect(result).toMatchObject({ status: "formatted", linesAdded: 2, linesRemoved: 2 });
+	});
+
+	it("#given a server returning an edit that adds lines #when the document is formatted #then the added and removed line counts differ", async () => {
+		// given
+		const { filePath } = workspaceWith("sample.ts", "const a=1;const b=2\n");
+		const edits: TextEdit[] = [
+			{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 19 } }, newText: "const a = 1;\nconst b = 2;" },
+		];
+
+		// when
+		const result = await formatDocumentWithClient(stubClient(edits), filePath);
+
+		// then
+		expect(result).toMatchObject({ status: "formatted", linesAdded: 2, linesRemoved: 1 });
+		expect(readFileSync(filePath, "utf-8")).toBe("const a = 1;\nconst b = 2;\n");
+	});
+
+	it("#given a server that does not advertise document formatting #when the document is formatted #then the result is unavailable and the file bytes are untouched", async () => {
+		// given
+		const original = "const a=1\n";
+		const { filePath } = workspaceWith("sample.ts", original);
+		const before = statSync(filePath);
+
+		// when
+		const result = await formatDocumentWithClient(stubClient(null), filePath);
+
+		// then
+		expect(result).toEqual({ status: "unavailable", reason: "capability_not_advertised" });
+		expect(readFileSync(filePath)).toEqual(Buffer.from(original));
+		expect(statSync(filePath).mtimeMs).toBe(before.mtimeMs);
+	});
+
+	it("#given a server returning no edits #when the document is formatted #then the result is unchanged and the file bytes are untouched", async () => {
+		// given
+		const original = "const a = 1;\n";
+		const { filePath } = workspaceWith("sample.ts", original);
+
+		// when
+		const result = await formatDocumentWithClient(stubClient([]), filePath);
+
+		// then
+		expect(result).toEqual({ status: "unchanged", linesAdded: 0, linesRemoved: 0 });
+		expect(readFileSync(filePath)).toEqual(Buffer.from(original));
+	});
+
+	it("#given edits that reproduce the current bytes #when the document is formatted #then the result is unchanged", async () => {
+		// given
+		const original = "const a = 1;\n";
+		const { filePath } = workspaceWith("sample.ts", original);
+		const edits: TextEdit[] = [
+			{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 12 } }, newText: "const a = 1;" },
+		];
+
+		// when
+		const result = await formatDocumentWithClient(stubClient(edits), filePath);
+
+		// then
+		expect(result.status).toBe("unchanged");
+		expect(readFileSync(filePath, "utf-8")).toBe(original);
+	});
+
+	it("#given the file shrinks after the server computed its edits #when the edits are applied #then the stale edit is rejected instead of corrupting the file", async () => {
+		// given
+		const { filePath } = workspaceWith("sample.ts", "const a=1\nconst b=2\n");
+		const staleEdits: TextEdit[] = [
+			{ range: { start: { line: 1, character: 0 }, end: { line: 1, character: 9 } }, newText: "const b = 2;" },
+		];
+		const racingClient = {
+			async formatDocument() {
+				writeFileSync(filePath, "short\n", "utf-8");
+				return staleEdits;
+			},
+			async openFile() {},
+		} as Pick<LspClient, "formatDocument" | "openFile"> as LspClient;
+
+		// when / then
+		await expect(formatDocumentWithClient(racingClient, filePath)).rejects.toThrow(/outside line/);
+		expect(readFileSync(filePath, "utf-8")).toBe("short\n");
+	});
+
+	it("#given a formatted document #when the write completes #then no temporary file is left behind", async () => {
+		// given
+		const { root, filePath } = workspaceWith("sample.ts", "const a=1\n");
+		const edits: TextEdit[] = [
+			{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 9 } }, newText: "const a = 1;" },
+		];
+
+		// when
+		await formatDocumentWithClient(stubClient(edits), filePath);
+
+		// then
+		expect(readFileSync(filePath, "utf-8")).toBe("const a = 1;\n");
+		expect(() => statSync(join(root, "sample.ts.tmp"))).toThrow();
+	});
+});