@openspecui/web 3.11.3 → 3.11.5

package/dist-ssg/server/entry-server.js

@@ -28325,13 +28325,13 @@ function reduceKernel(state, event) {
 				persist: "none"
 			};
 		case "APPLY_LAYOUT": {
-			if (event.layout.updatedAt <= state.updatedAt) return {
+			const merged = mergeLayout(event.layout);
+			if (!(event.layout.updatedAt !== state.updatedAt || !areTabsEqual(state.mainTabs, merged.mainTabs) || !areTabsEqual(state.bottomTabs, merged.bottomTabs)) || !event.force && event.layout.updatedAt <= state.updatedAt) return {
 				nextState: state,
 				changed: false,
 				notify: [],
 				persist: "none"
 			};
-			const merged = mergeLayout(event.layout);
 			return {
 				nextState: {
 					...state,
@@ -28688,14 +28688,11 @@ var NavController = class {
 	rebindProjectScopedLayout(storageKey) {
 		const scopedLocal = readLocalStorageByKey(storageKey);
 		if (scopedLocal) {
-			const merged = mergeLayout(scopedLocal);
-			this.state = normalizeState({
-				...this.state,
-				mainTabs: merged.mainTabs,
-				bottomTabs: merged.bottomTabs,
-				updatedAt: scopedLocal.updatedAt
+			this.dispatch({
+				type: "APPLY_LAYOUT",
+				layout: scopedLocal,
+				force: true
 			});
-			this.normalizeUrl();
 			return;
 		}
 		this.state = normalizeState({
@@ -32292,6 +32289,120 @@ ZodOptional.create;
 ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 ZodPipeline.create;
+//#endregion
+//#region ../core/src/translation-task-control.ts
+var BATCH_TRANSLATION_ERROR_KINDS = [
+	"timeout",
+	"memory-limit",
+	"runtime",
+	"abort"
+];
+async function runControlledTranslationTask(task, options = {}) {
+	const controller = new AbortController();
+	const cleanupCallbacks = [];
+	const parentSignal = options.signal;
+	const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
+	if (parentSignal) if (parentSignal.aborted) controller.abort(parentSignal.reason);
+	else {
+		const onAbort = () => controller.abort(parentSignal.reason);
+		parentSignal.addEventListener("abort", onAbort, { once: true });
+		cleanupCallbacks.push(() => parentSignal.removeEventListener("abort", onAbort));
+	}
+	if (controller.signal.aborted) {
+		cleanupCallbacks.forEach((callback) => callback());
+		return {
+			ok: false,
+			error: normalizeBatchTranslationError(controller.signal.reason, parentSignal)
+		};
+	}
+	let timer;
+	let timeoutError;
+	const taskPromise = Promise.resolve().then(() => task(controller.signal));
+	taskPromise.catch(() => void 0);
+	const races = [taskPromise];
+	if (!controller.signal.aborted) races.push(new Promise((_, reject) => {
+		const onAbort = () => reject(new DOMException("Translation cancelled.", "AbortError"));
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+		cleanupCallbacks.push(() => controller.signal.removeEventListener("abort", onAbort));
+	}));
+	if (timeoutMs !== void 0) races.push(new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			timeoutError = /* @__PURE__ */ new Error(`Translation task timed out after ${timeoutMs}ms.`);
+			controller.abort(timeoutError);
+			reject(timeoutError);
+		}, timeoutMs);
+	}));
+	try {
+		return {
+			ok: true,
+			value: await Promise.race(races)
+		};
+	} catch (error) {
+		controller.abort(error);
+		if (timeoutError && controller.signal.reason === timeoutError) return {
+			ok: false,
+			error: {
+				kind: "timeout",
+				message: timeoutError.message
+			}
+		};
+		return {
+			ok: false,
+			error: normalizeBatchTranslationError(error, parentSignal)
+		};
+	} finally {
+		if (timer) clearTimeout(timer);
+		cleanupCallbacks.forEach((callback) => callback());
+	}
+}
+function normalizeBatchTranslationError(error, parentSignal) {
+	if (isBatchTranslationError(error)) return error;
+	if (parentSignal?.aborted) return {
+		kind: "abort",
+		message: readAbortMessage(parentSignal.reason) ?? "Translation cancelled."
+	};
+	if (error instanceof DOMException && error.name === "AbortError") return {
+		kind: "abort",
+		message: readAbortMessage(error) ?? "Translation cancelled."
+	};
+	const message = getErrorMessage$2(error);
+	if (isTimeoutMessage(message)) return {
+		kind: "timeout",
+		message
+	};
+	if (isMemoryLimitMessage(message)) return {
+		kind: "memory-limit",
+		message
+	};
+	return {
+		kind: "runtime",
+		message
+	};
+}
+function normalizeTimeoutMs(timeoutMs) {
+	return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.floor(timeoutMs) : void 0;
+}
+function getErrorMessage$2(error) {
+	if (error instanceof Error && error.message.trim().length > 0) return error.message;
+	if (typeof error === "string" && error.trim().length > 0) return error;
+	return "Translation failed.";
+}
+function readAbortMessage(reason) {
+	if (reason instanceof Error && reason.message.trim().length > 0) return reason.message;
+	if (typeof reason === "string" && reason.trim().length > 0) return reason;
+}
+function isTimeoutMessage(message) {
+	return /\btime(?:d)?\s*out\b/i.test(message);
+}
+function isMemoryLimitMessage(message) {
+	return /out of memory/i.test(message) || /memory limit/i.test(message) || /insufficient memory/i.test(message) || /ERR_WORKER_OUT_OF_MEMORY/i.test(message);
+}
+function isBatchTranslationError(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const kind = Reflect.get(value, "kind");
+	const message = Reflect.get(value, "message");
+	return typeof kind === "string" && BATCH_TRANSLATION_ERROR_KINDS.includes(kind) && typeof message === "string" && message.length > 0;
+}
 var TranslationEngineIdSchema = enumType([
 	"browser",
 	"local",
@@ -32312,6 +32423,7 @@ enumType([
 	"local-llama",
 	"openai"
 ]);
+var DEFAULT_BATCH_TRANSLATION_TIMEOUT_MS = 15e3;
 var LocalModelDownloadStatusSchema = enumType([
 	"not-downloaded",
 	"queued",
@@ -32553,27 +32665,61 @@ var TranslationOpenAISettingsSchema = objectType({
 	token: stringType().default(""),
 	model: stringType().default("gpt-4.1-mini")
 });
+var TranslationOpenAISettingsUpdateSchema = objectType({
+	baseUrl: stringType().optional(),
+	token: stringType().optional(),
+	model: stringType().optional()
+});
 var TranslationLocalSettingsSchema = objectType({
 	model: stringType().default("Xenova/nllb-200-distilled-600M"),
 	selectedGroupId: stringType().optional(),
-	hfEndpoint: stringType().default("")
+	hfEndpoint: stringType().default(""),
+	memoryBudgetPercent: numberType().min(0).max(100).default(25)
+});
+var TranslationLocalSettingsUpdateSchema = objectType({
+	model: stringType().min(1).optional(),
+	selectedGroupId: stringType().min(1).nullable().optional(),
+	hfEndpoint: stringType().optional(),
+	memoryBudgetPercent: numberType().min(0).max(100).optional()
 });
 var TranslationLocalCt2SettingsSchema = objectType({
 	model: stringType().default("ooeoeo/opus-mt-en-zh-ct2-float16"),
 	selectedGroupId: stringType().optional(),
-	hfEndpoint: stringType().default("")
+	hfEndpoint: stringType().default(""),
+	memoryBudgetPercent: numberType().min(0).max(100).default(25)
+});
+var TranslationLocalCt2SettingsUpdateSchema = objectType({
+	model: stringType().min(1).optional(),
+	selectedGroupId: stringType().min(1).nullable().optional(),
+	hfEndpoint: stringType().optional(),
+	memoryBudgetPercent: numberType().min(0).max(100).optional()
 });
 var TranslationLocalLlamaSettingsSchema = objectType({
 	model: stringType().default("bartowski/Qwen2.5-0.5B-Instruct-GGUF"),
 	selectedGroupId: stringType().optional(),
-	hfEndpoint: stringType().default("")
+	hfEndpoint: stringType().default(""),
+	memoryBudgetPercent: numberType().min(0).max(100).default(25)
+});
+var TranslationLocalLlamaSettingsUpdateSchema = objectType({
+	model: stringType().min(1).optional(),
+	selectedGroupId: stringType().min(1).nullable().optional(),
+	hfEndpoint: stringType().optional(),
+	memoryBudgetPercent: numberType().min(0).max(100).optional()
 });
 objectType({
+	engineId: TranslationEngineIdSchema.default(DEFAULT_TRANSLATION_ENGINE_ID),
 	openai: TranslationOpenAISettingsSchema.default(TranslationOpenAISettingsSchema.parse({})),
 	local: TranslationLocalSettingsSchema.default(TranslationLocalSettingsSchema.parse({})),
 	localCt2: TranslationLocalCt2SettingsSchema.default(TranslationLocalCt2SettingsSchema.parse({})),
 	localLlama: TranslationLocalLlamaSettingsSchema.default(TranslationLocalLlamaSettingsSchema.parse({}))
 });
+objectType({
+	engineId: TranslationEngineIdSchema.optional(),
+	openai: TranslationOpenAISettingsUpdateSchema.optional(),
+	local: TranslationLocalSettingsUpdateSchema.optional(),
+	localCt2: TranslationLocalCt2SettingsUpdateSchema.optional(),
+	localLlama: TranslationLocalLlamaSettingsUpdateSchema.optional()
+});
 objectType({
 	engineId: TranslationEngineIdSchema,
 	sourceLanguage: stringType().min(1),
@@ -32582,11 +32728,16 @@ objectType({
 	selectedGroupId: stringType().min(1).optional(),
 	inputs: arrayType(stringType()).min(1),
 	instructions: stringType().optional(),
-	context: stringType().optional()
+	context: stringType().optional(),
+	timeoutMs: numberType().int().positive().default(DEFAULT_BATCH_TRANSLATION_TIMEOUT_MS)
 });
 objectType({
 	index: numberType().int().nonnegative(),
-	output: stringType()
+	output: stringType().optional(),
+	error: objectType({
+		kind: enumType(BATCH_TRANSLATION_ERROR_KINDS),
+		message: stringType().min(1)
+	}).optional()
 });
 var DocumentTranslationDisplayModeSchema = enumType(["direct", "bilingual"]);
 var TranslationEngineProjectSettingsSchema = objectType({
@@ -32604,6 +32755,21 @@ var TranslationEngineProjectSettingsSchema = objectType({
 	}).default({}),
 	openai: objectType({ model: stringType().min(1).optional() }).default({})
 }).default({});
+var TranslationEngineProjectSettingsUpdateSchema = objectType({
+	local: objectType({
+		model: stringType().min(1).optional(),
+		selectedGroupId: stringType().min(1).nullable().optional()
+	}).optional(),
+	localCt2: objectType({
+		model: stringType().min(1).optional(),
+		selectedGroupId: stringType().min(1).nullable().optional()
+	}).optional(),
+	localLlama: objectType({
+		model: stringType().min(1).optional(),
+		selectedGroupId: stringType().min(1).nullable().optional()
+	}).optional(),
+	openai: objectType({ model: stringType().min(1).optional() }).optional()
+});
 var DocumentTranslationConfigSchema = objectType({
 	enabled: booleanType().default(false),
 	targetLanguage: stringType().min(1).default("zh"),
@@ -32612,7 +32778,18 @@ var DocumentTranslationConfigSchema = objectType({
 	engineId: TranslationEngineIdSchema.default(DEFAULT_TRANSLATION_ENGINE_ID),
 	engines: TranslationEngineProjectSettingsSchema
 });
-objectType({ entryLimit: numberType().int().min(100).max(2e5).default(1e4) });
+objectType({
+	enabled: booleanType().optional(),
+	targetLanguage: stringType().min(1).optional(),
+	displayMode: DocumentTranslationDisplayModeSchema.optional(),
+	cacheEnabled: booleanType().optional(),
+	engineId: TranslationEngineIdSchema.optional(),
+	engines: TranslationEngineProjectSettingsUpdateSchema.optional()
+});
+var DEFAULT_TRANSLATION_CACHE_ENTRY_LIMIT = 1e4;
+var MAX_TRANSLATION_CACHE_ENTRY_LIMIT = 2e5;
+objectType({ entryLimit: numberType().int().min(100).max(MAX_TRANSLATION_CACHE_ENTRY_LIMIT).default(DEFAULT_TRANSLATION_CACHE_ENTRY_LIMIT) });
+objectType({ entryLimit: numberType().int().min(100).max(MAX_TRANSLATION_CACHE_ENTRY_LIMIT).optional() });
 objectType({
 	key: stringType().min(1),
 	keyHash: stringType().min(1),
@@ -68061,6 +68238,25 @@ var InputPanel = class extends i {
 		}));
 		this.requestUpdate();
 	}
+	_stopToolbarControlPointer(e) {
+		e.stopPropagation();
+		e.preventDefault();
+	}
+	_stopToolbarControlEvent(e) {
+		e.stopPropagation();
+	}
+	_switchTabFromToolbar(e, tab) {
+		this._stopToolbarControlEvent(e);
+		this._switchTab(tab);
+	}
+	_toggleLayoutFromToolbar(e) {
+		this._stopToolbarControlEvent(e);
+		this._toggleLayout();
+	}
+	_closeFromToolbar(e) {
+		this._stopToolbarControlEvent(e);
+		this._close();
+	}
 	_toggleLayout() {
 		this.layout = this.layout === "fixed" ? "floating" : "fixed";
 		if (this.layout === "fixed") this._closeFloatingDialog();
@@ -68297,17 +68493,32 @@ var InputPanel = class extends i {
                 class="tab-btn"
                 part="tab-btn"
                 ?data-active=${this.activeTab === t.id}
-                @click=${() => this._switchTab(t.id)}
+                @pointerdown=${(e) => this._stopToolbarControlPointer(e)}
+                @mousedown=${(e) => this._stopToolbarControlPointer(e)}
+                @click=${(e) => this._switchTabFromToolbar(e, t.id)}
               >
                 ${t.icon} ${this.activeTab === t.id ? t.label : ""}
               </button>
             `)}
         </div>
         <div class="action-group">
-          <button class="icon-btn" @click=${this._toggleLayout} title="Toggle layout mode">
+          <button
+            class="icon-btn"
+            @pointerdown=${(e) => this._stopToolbarControlPointer(e)}
+            @mousedown=${(e) => this._stopToolbarControlPointer(e)}
+            @click=${(e) => this._toggleLayoutFromToolbar(e)}
+            title="Toggle layout mode"
+          >
             ${this.layout === "fixed" ? iconPin(14) : iconPinOff(14)}
           </button>
-          <button class="icon-btn" part="close-btn" @click=${this._close} title="Close panel">
+          <button
+            class="icon-btn"
+            part="close-btn"
+            @pointerdown=${(e) => this._stopToolbarControlPointer(e)}
+            @mousedown=${(e) => this._stopToolbarControlPointer(e)}
+            @click=${(e) => this._closeFromToolbar(e)}
+            title="Close panel"
+          >
             ${iconX(14)}
           </button>
         </div>
@@ -90847,30 +91058,12 @@ var ShortcutTab = class extends i {
 			composed: true
 		}));
 	}
-	async _handleCommand(command) {
-		if (command === "copy") {
-			const selection = window.getSelection()?.toString() ?? "";
-			if (!selection) return;
-			try {
-				await navigator.clipboard.writeText(selection);
-			} catch {
-				document.execCommand("copy");
-			}
-			return;
-		}
-		if (command === "paste") {
-			try {
-				const text = await navigator.clipboard.readText();
-				if (text) this._send(text);
-			} catch {}
-			return;
-		}
-		const active = document.activeElement;
-		if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement) {
-			active.select();
-			return;
-		}
-		document.execCommand("selectAll");
+	_handleCommand(command) {
+		this.dispatchEvent(new CustomEvent("input-panel:command", {
+			detail: { command },
+			bubbles: true,
+			composed: true
+		}));
 	}
 	_dpadData(event, width, height, container) {
 		const local = container.toLocal(event.global);
@@ -90880,7 +91073,7 @@ var ShortcutTab = class extends i {
 		if (Math.abs(dx) > Math.abs(dy)) return dx < 0 ? "\x1B[D" : "\x1B[C";
 		return dy < 0 ? "\x1B[A" : "\x1B[B";
 	}
-	async _activateShortcut(item, event, width, height, container) {
+	_activateShortcut(item, event, width, height, container) {
 		if (item.kind === "dpad") {
 			this._send(this._dpadData(event, width, height, container));
 			return;
@@ -90895,7 +91088,7 @@ var ShortcutTab = class extends i {
 			this._send(action.text);
 			return;
 		}
-		await this._handleCommand(action.command);
+		this._handleCommand(action.command);
 	}
 	_setActivePage(pageId) {
 		if (this.activePageId === pageId) return;
@@ -91444,8 +91637,11 @@ var VirtualKeyboardTab = class extends i {
 		this._activeKey = null;
 		this._activePointerId = null;
 	}
+	_hostPlatform() {
+		return this.platform === "windows" || this.platform === "macos" || this.platform === "common" ? this.platform : detectHostPlatform();
+	}
 	getRows() {
-		return LAYOUTS[this.platform === "windows" || this.platform === "macos" || this.platform === "common" ? this.platform : detectHostPlatform()];
+		return LAYOUTS[this._hostPlatform()];
 	}
 	async _initPixi() {
 		const host = this.shadowRoot?.querySelector(".pixi-host");
@@ -91791,14 +91987,44 @@ var VirtualKeyboardTab = class extends i {
 		if (this._isShifted(def, forceShift) && def.shift) return def.shift.data;
 		return def.data;
 	}
-	_sendKey(def, forceShift) {
+	_resolveTerminalData(def, forceShift) {
 		let data = this._resolveOutputData(def, forceShift);
-		if (!data) return;
+		if (!data) return "";
 		if (this._modifiers.ctrl && data.length === 1) {
 			const code = data.toUpperCase().charCodeAt(0) - 64;
 			if (code > 0 && code < 32) data = String.fromCharCode(code);
 		}
 		if (this._modifiers.alt || this._modifiers.meta) data = `\x1b${data}`;
+		return data;
+	}
+	_resolvePrimaryCommand(def) {
+		if (this._modifiers.alt || this._modifiers.shift) return null;
+		if (!(this._hostPlatform() === "macos" ? this._modifiers.meta && !this._modifiers.ctrl : this._modifiers.ctrl && !this._modifiers.meta)) return null;
+		const key = def.data.toLowerCase();
+		if (key === "c") return "copy";
+		if (key === "v") return "paste";
+		if (key === "a") return "select-all";
+		return null;
+	}
+	_sendCommand(command, fallbackData) {
+		this.dispatchEvent(new CustomEvent("input-panel:command", {
+			detail: {
+				command,
+				fallbackData
+			},
+			bubbles: true,
+			composed: true
+		}));
+	}
+	_sendKey(def, forceShift) {
+		const data = this._resolveTerminalData(def, forceShift);
+		if (!data) return;
+		const command = this._resolvePrimaryCommand(def);
+		if (command) {
+			const fallbackData = this._hostPlatform() === "macos" ? void 0 : data;
+			this._sendCommand(command, fallbackData);
+			return;
+		}
 		this.dispatchEvent(new CustomEvent("input-panel:send", {
 			detail: { data },
 			bubbles: true,
@@ -92326,9 +92552,27 @@ var EDGE_SCROLL_OVERSHOOT = 15;
 function isTouchDevice() {
 	return "ontouchstart" in window || navigator.maxTouchPoints > 0;
 }
+function isTerminalTouchMouseOverlay(element) {
+	return element instanceof HTMLElement && element.classList.contains("terminal-touch-mouse-overlay");
+}
+function resolveTerminalPointerTarget(container, clientX, clientY) {
+	let element = document.elementFromPoint(clientX, clientY);
+	if (element && isTerminalTouchMouseOverlay(element)) {
+		const overlayElement = element;
+		const previousPointerEvents = overlayElement.style.pointerEvents;
+		overlayElement.style.pointerEvents = "none";
+		element = document.elementFromPoint(clientX, clientY);
+		overlayElement.style.pointerEvents = previousPointerEvents;
+	}
+	if (element && container.contains(element) && !isTerminalTouchMouseOverlay(element)) return element;
+	return container.querySelector(".xterm-screen") ?? container;
+}
 function isInputPanelTab(value) {
 	return value === "input" || value === "keys" || value === "shortcuts" || value === "trackpad" || value === "settings";
 }
+function isInputPanelCommand(value) {
+	return value === "copy" || value === "paste" || value === "select-all";
+}
 function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
@@ -92575,6 +92819,7 @@ var InputPanelAddon = class InputPanelAddon {
 	_persistentCleanups = [];
 	_listenersAttached = false;
 	_onInput;
+	_onCommand;
 	_onOpenCb;
 	_onCloseCb;
 	_getHistory;
@@ -92590,6 +92835,7 @@ var InputPanelAddon = class InputPanelAddon {
 	_hasOwnPersistedState;
 	constructor(opts) {
 		this._onInput = opts?.onInput ?? (() => {});
+		this._onCommand = opts?.onCommand ?? null;
 		this._onOpenCb = opts?.onOpen ?? null;
 		this._onCloseCb = opts?.onClose ?? null;
 		this._getHistory = opts?.getHistory ?? null;
@@ -92625,6 +92871,9 @@ var InputPanelAddon = class InputPanelAddon {
 	set onInput(fn) {
 		this._onInput = fn;
 	}
+	set onCommand(fn) {
+		this._onCommand = fn;
+	}
 	setPlatform(platform) {
 		this._platform = platform;
 		this._applyPlatformToPanel();
@@ -92781,6 +93030,18 @@ var InputPanelAddon = class InputPanelAddon {
 				}).catch(() => {});
 			}
 		});
+		this._on(panel, "input-panel:command", (e) => {
+			const detail = e.detail;
+			if (!isRecord$1(detail)) return;
+			const command = detail.command;
+			if (!isInputPanelCommand(command)) return;
+			const fallbackData = typeof detail.fallbackData === "string" ? detail.fallbackData : void 0;
+			Promise.resolve(this._onCommand?.(command, { fallbackData }) ?? false).then((handled) => {
+				if (!handled && fallbackData) this._onInput(fallbackData);
+			}).catch(() => {
+				if (fallbackData) this._onInput(fallbackData);
+			});
+		});
 		this._on(inputTab, "input-panel:input-change", (e) => {
 			const value = e.detail?.value;
 			if (typeof value === "string") {
@@ -92998,9 +93259,7 @@ var InputPanelAddon = class InputPanelAddon {
 	_resolveTarget(clientX, clientY) {
 		const container = this._getTerminalHostElement();
 		if (!container) return document.body;
-		const el = document.elementFromPoint(clientX, clientY);
-		if (el && container.contains(el)) return el;
-		return container.querySelector(".xterm-screen") ?? container;
+		return resolveTerminalPointerTarget(container, clientX, clientY);
 	}
 	_dispatchMouse(type, opts = {}) {
 		const coords = this._getClientCoords();
@@ -93155,6 +93414,55 @@ var InputPanelAddon = class InputPanelAddon {
 	}
 };
 //#endregion
+//#region src/lib/google-font-loader.ts
+function getPreferredGoogleFontsHosts(lang) {
+	const useCnCdn = /^zh\b/i.test(lang);
+	return {
+		apiHost: useCnCdn ? "https://fonts.googleapis.cn" : "https://fonts.googleapis.com",
+		staticHost: useCnCdn ? "https://fonts.gstatic.cn" : "https://fonts.gstatic.com"
+	};
+}
+function encodeGoogleFontFamily(family) {
+	return family.trim().replace(/ /g, "+");
+}
+function buildGoogleFontsStylesheetHref(options) {
+	const families = options.families.map(encodeGoogleFontFamily).filter(Boolean);
+	const { apiHost } = getPreferredGoogleFontsHosts(options.lang ?? "");
+	const familyParams = families.map((family) => `family=${family}`);
+	const displayParam = `display=${options.display ?? "swap"}`;
+	return `${apiHost}/css2?${[...familyParams, displayParam].join("&")}`;
+}
+/**
+* Legacy Google Fonts loader retained for optional large CJK/JCK font families.
+* The app shell uses local @fontsource assets by default.
+*/
+function loadGoogleFontsStylesheet(options) {
+	const documentRef = options.documentRef ?? (typeof document === "undefined" ? null : document);
+	if (!documentRef || options.families.length === 0) return null;
+	const lang = options.lang ?? (typeof navigator === "undefined" ? "" : navigator.languages && navigator.languages[0] || navigator.language || navigator.userLanguage || "");
+	const hosts = getPreferredGoogleFontsHosts(lang);
+	const href = buildGoogleFontsStylesheetHref({
+		...options,
+		lang
+	});
+	if (documentRef.head.querySelector(`link[href="${href}"]`)) return null;
+	const preconnectApi = documentRef.createElement("link");
+	preconnectApi.rel = "preconnect";
+	preconnectApi.href = hosts.apiHost;
+	preconnectApi.dataset.openspecGoogleFonts = "preconnect-api";
+	const preconnectStatic = documentRef.createElement("link");
+	preconnectStatic.rel = "preconnect";
+	preconnectStatic.href = hosts.staticHost;
+	preconnectStatic.crossOrigin = "anonymous";
+	preconnectStatic.dataset.openspecGoogleFonts = "preconnect-static";
+	const stylesheet = documentRef.createElement("link");
+	stylesheet.rel = "stylesheet";
+	stylesheet.href = href;
+	stylesheet.dataset.openspecGoogleFonts = "stylesheet";
+	documentRef.head.append(preconnectApi, preconnectStatic, stylesheet);
+	return stylesheet;
+}
+//#endregion
 //#region src/lib/user-gesture-audio-context.ts
 var audioContext = null;
 var audioContextPromise = null;
@@ -93558,6 +93866,146 @@ var TerminalInputHistoryStore = class {
 	}
 };
 //#endregion
+//#region src/lib/terminal-keybindings.ts
+function isKeydown(event) {
+	return event.type === "keydown";
+}
+function keyEquals(event, key) {
+	return event.key.toLowerCase() === key;
+}
+function hasPrimaryModifier(event) {
+	return event.metaKey || event.ctrlKey;
+}
+function hasPlainPrimaryModifier(event) {
+	return hasPrimaryModifier(event) && !event.altKey;
+}
+function resolveClipboard(context) {
+	if (context.clipboard) return context.clipboard;
+	if (typeof navigator === "undefined") return null;
+	return navigator.clipboard ?? null;
+}
+function runAsync(task, context) {
+	task.catch((error) => {
+		context.onAsyncError?.(error);
+	});
+}
+async function copySelection(context, selection) {
+	const clipboard = resolveClipboard(context);
+	if (!clipboard?.writeText) return;
+	await clipboard.writeText(selection);
+}
+async function pasteClipboard(context) {
+	const clipboard = resolveClipboard(context);
+	if (!clipboard?.readText) return;
+	const text = await clipboard.readText();
+	if (!text) return;
+	try {
+		context.terminal.paste?.(text);
+		if (context.terminal.paste) return;
+	} catch {}
+	context.writeInput(text);
+}
+var defaultTerminalKeybindings = [
+	{
+		id: "terminal.copy-selection",
+		handle: (event, context) => {
+			if (!isKeydown(event) || !hasPlainPrimaryModifier(event) || !keyEquals(event, "c")) return null;
+			if (!context.terminal.hasSelection?.()) return "allow";
+			return copySelectionCommand(context);
+		}
+	},
+	{
+		id: "terminal.paste-clipboard",
+		handle: (event, context) => {
+			if (!isKeydown(event) || !hasPlainPrimaryModifier(event) || !keyEquals(event, "v")) return null;
+			return pasteClipboardCommand(context);
+		}
+	},
+	{
+		id: "terminal.select-all",
+		handle: (event, context) => {
+			if (!isKeydown(event) || !event.metaKey || event.ctrlKey || event.altKey) return null;
+			if (!keyEquals(event, "a")) return null;
+			return selectAllCommand(context);
+		}
+	},
+	{
+		id: "terminal.zoom-in",
+		handle: (event, context) => {
+			if (!isKeydown(event) || !hasPrimaryModifier(event)) return null;
+			if (event.key !== "=" && event.key !== "+") return null;
+			context.zoomFont(1);
+			return "block";
+		}
+	},
+	{
+		id: "terminal.zoom-out",
+		handle: (event, context) => {
+			if (!isKeydown(event) || !hasPrimaryModifier(event) || event.key !== "-") return null;
+			context.zoomFont(-1);
+			return "block";
+		}
+	},
+	{
+		id: "terminal.zoom-reset",
+		handle: (event, context) => {
+			if (!isKeydown(event) || !hasPrimaryModifier(event) || event.key !== "0") return null;
+			context.resetFontSize();
+			return "block";
+		}
+	}
+];
+function copySelectionCommand(context) {
+	if (!context.terminal.hasSelection?.()) return "allow";
+	const selection = context.terminal.getSelection?.() ?? "";
+	if (!selection) return "allow";
+	runAsync(copySelection(context, selection), context);
+	return "block";
+}
+function pasteClipboardCommand(context) {
+	if (!resolveClipboard(context)?.readText) return "allow";
+	runAsync(pasteClipboard(context), context);
+	return "block";
+}
+function selectAllCommand(context) {
+	if (!context.terminal.selectAll) return "allow";
+	context.terminal.selectAll();
+	return "block";
+}
+var defaultTerminalCommandBindings = [
+	{
+		id: "terminal.command.copy-selection",
+		command: "copy",
+		run: copySelectionCommand
+	},
+	{
+		id: "terminal.command.paste-clipboard",
+		command: "paste",
+		run: pasteClipboardCommand
+	},
+	{
+		id: "terminal.command.select-all",
+		command: "select-all",
+		run: selectAllCommand
+	}
+];
+var TerminalKeybindingRegistry = class {
+	constructor(bindings = defaultTerminalKeybindings, commandBindings = defaultTerminalCommandBindings) {
+		this.bindings = bindings;
+		this.commandBindings = commandBindings;
+	}
+	handleKeyEvent(event, context) {
+		for (const binding of this.bindings) {
+			const result = binding.handle(event, context);
+			if (result) return result;
+		}
+		return "allow";
+	}
+	runCommand(command, context) {
+		return this.commandBindings.find((item) => item.command === command)?.run(context) ?? "allow";
+	}
+};
+//#endregion
 //#region src/lib/terminal-theme.ts
 var TERMINAL_THEME_REGISTRY = {
 	"default-light": {
@@ -93747,7 +94195,7 @@ function resolveTerminalTheme(input) {
 }
 //#endregion
 //#region src/lib/terminal-controller.ts
-var DEFAULT_FONT_FAMILY = "ui-monospace, SFMono-Regular, \"SF Mono\", Menlo, Consolas, monospace";
+var DEFAULT_FONT_FAMILY = "\"JetBrains Mono Variable\", \"JetBrains Mono\", ui-monospace, SFMono-Regular, \"SF Mono\", Menlo, Consolas, monospace";
 var DEFAULT_TERMINAL_CONFIG = {
 	fontSize: 13,
 	fontFamily: "",
@@ -93796,6 +94244,10 @@ var GOOGLE_FONT_PRESETS = [
 	"Ubuntu Mono",
 	"Space Mono"
 ];
+var LOCAL_FONT_FAMILY_ALIASES = {
+	"JetBrains Mono": "\"JetBrains Mono Variable\"",
+	"Share Tech Mono": "\"Share Tech Mono\""
+};
 /** Already-injected font sources, used for deduplication */
 var loadedFontSources = /* @__PURE__ */ new Set();
 /** Extract a font name from a URL pathname (strip extension, replace dashes with spaces) */
@@ -93844,13 +94296,8 @@ async function loadFontSource(source) {
 function loadGoogleFont(fontName) {
 	const key = `google:${fontName}`;
 	if (loadedFontSources.has(key)) return;
-	const lang = navigator.language ?? "";
-	const apiHost = /^zh\b/i.test(lang) ? "https://fonts.googleapis.cn" : "https://fonts.googleapis.com";
-	const link = document.createElement("link");
-	link.rel = "stylesheet";
-	link.href = `${apiHost}/css2?family=${fontName.replace(/ /g, "+")}&display=swap`;
-	link.dataset.fontSrc = key;
-	document.head.appendChild(link);
+	const link = loadGoogleFontsStylesheet({ families: [fontName] });
+	if (link) link.dataset.fontSrc = key;
 	loadedFontSources.add(key);
 }
 var TerminalController = class {
@@ -93862,6 +94309,7 @@ var TerminalController = class {
 	snapshotCache = null;
 	inputHistoryStore = new TerminalInputHistoryStore();
 	bellSoundEngine = new TerminalBellSoundEngine();
+	keybindings = new TerminalKeybindingRegistry();
 	ghosttyModule = null;
 	ghosttyInitPromise = null;
 	appDarkMode = false;
@@ -94036,6 +94484,7 @@ var TerminalController = class {
 	createInputPanelAddon(sessionId, platform) {
 		return new InputPanelAddon({
 			onInput: (data) => this.writeToSession(sessionId, data),
+			onCommand: (command) => this.runInputPanelCommand(sessionId, command),
 			getHistory: async () => this.inputHistoryStore.list(),
 			addHistory: async (text) => this.inputHistoryStore.add(text),
 			subscribeHistory: (listener) => this.inputHistoryStore.subscribe(listener),
@@ -94048,6 +94497,17 @@ var TerminalController = class {
 			}
 		});
 	}
+	runInputPanelCommand(sessionId, command) {
+		const instance = this.instances.get(sessionId);
+		if (!instance) return false;
+		return this.keybindings.runCommand(command, {
+			terminal: instance.terminal,
+			writeInput: (data) => this.writeToSession(sessionId, data),
+			zoomFont: (delta) => this.zoomFont(delta),
+			resetFontSize: () => this.resetFontSize(),
+			onAsyncError: (error) => console.error("[terminal] input panel command failed:", error)
+		}) === "block";
+	}
 	applyGhosttyBackground(instance, container) {
 		if (instance.rendererEngine !== "ghostty") return;
 		const currentTheme = instance.terminal.options.theme ?? {};
@@ -94092,20 +94552,18 @@ var TerminalController = class {
 			}
 			const mod = event.metaKey || event.ctrlKey;
 			if (event.type !== "keydown" || !mod) return this.getKeyEventResult(engine, "allow");
-			let handled = false;
-			if ((event.key === "=" || event.key === "+") && mod) {
-				this.zoomFont(1);
-				handled = true;
-			}
-			if (event.key === "-" && mod && !handled) {
-				this.zoomFont(-1);
-				handled = true;
-			}
-			if (event.key === "0" && mod && !handled) {
-				this.resetFontSize();
-				handled = true;
+			const keybindingResult = this.keybindings.handleKeyEvent(event, {
+				terminal,
+				writeInput,
+				zoomFont: (delta) => this.zoomFont(delta),
+				resetFontSize: () => this.resetFontSize(),
+				onAsyncError: (error) => console.error("[terminal] keybinding failed:", error)
+			});
+			if (keybindingResult === "block") {
+				event.preventDefault();
+				event.stopPropagation();
 			}
-			return this.getKeyEventResult(engine, handled ? "block" : "allow");
+			return this.getKeyEventResult(engine, keybindingResult);
 		});
 	}
 	bindTerminalInput(instance) {
@@ -94383,12 +94841,16 @@ var TerminalController = class {
 		}
 		const entries = raw.split(/[,]+/).map((s) => s.trim()).filter(Boolean);
 		const resolved = [];
-		for (const entry of entries) if (GOOGLE_FONT_PRESETS.includes(entry)) {
-			loadGoogleFont(entry);
-			resolved.push(entry);
-		} else {
-			const name = await loadFontSource(entry);
-			if (name) resolved.push(name);
+		for (const entry of entries) {
+			const localFontFamily = LOCAL_FONT_FAMILY_ALIASES[entry];
+			if (localFontFamily) resolved.push(localFontFamily);
+			else if (GOOGLE_FONT_PRESETS.includes(entry)) {
+				loadGoogleFont(entry);
+				resolved.push(entry);
+			} else {
+				const name = await loadFontSource(entry);
+				if (name) resolved.push(name);
+			}
 		}
 		resolved.push(DEFAULT_FONT_FAMILY);
 		this._setFontFamily(resolved.join(", "));
@@ -95376,7 +95838,7 @@ function Dialog({ open, title, headerActions, onClose, onDismissRequest, onClose
 			className: `flex h-full w-full items-center justify-center px-4 py-4 ${contentClassName} ${contentShellClassName}`,
 			children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
 				ref: panelRef,
-				className: `bg-background text-foreground relative flex h-fit w-[calc(100%-0.5rem)] max-w-2xl flex-col overflow-hidden rounded-[var(--openspec-dialog-radius,0.75rem)] border shadow-xl ${borderClass} ${className}`,
+				className: `@container/dialog bg-background text-foreground relative flex h-fit w-[calc(100%-0.5rem)] max-w-2xl flex-col overflow-hidden rounded-[var(--openspec-dialog-radius,0.75rem)] border shadow-xl ${borderClass} ${className}`,
 				style: { maxHeight },
 				children: [
 					/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
@@ -114711,6 +115173,25 @@ function navigateHashAnchor(anchorElement, hash) {
 }
 //#endregion
 //#region ../browser-translator/dist/index.mjs
+var DEFAULT_SOURCE_LANGUAGE$1 = "en";
+async function probeBrowserTranslator(targetLanguage, sourceLanguage = DEFAULT_SOURCE_LANGUAGE$1, win = window) {
+	const translator = win.Translator;
+	if (!translator) return {
+		availability: "missing",
+		message: "Browser Translator API is not exposed."
+	};
+	try {
+		return { availability: normalizeAvailability$1(await translator.availability({
+			sourceLanguage,
+			targetLanguage
+		})) };
+	} catch (error) {
+		return {
+			availability: "error",
+			message: getErrorMessage$1(error)
+		};
+	}
+}
 async function scanBrowserTranslationSupportTable(options) {
 	const translator = (options.win ?? window).Translator;
 	if (!translator) return {
@@ -114768,6 +115249,63 @@ async function scanBrowserTranslationSupportTable(options) {
 		rows
 	};
 }
+async function prepareBrowserTranslator(targetLanguage, options) {
+	const sourceLanguage = options.sourceLanguage ?? DEFAULT_SOURCE_LANGUAGE$1;
+	const win = options.win ?? window;
+	const translator = win.Translator;
+	if (!translator) return {
+		availability: "missing",
+		message: "Browser Translator API is not exposed."
+	};
+	try {
+		const initialStatus = await probeBrowserTranslator(targetLanguage, sourceLanguage, win);
+		if (initialStatus.availability === "missing" || initialStatus.availability === "unavailable" || initialStatus.availability === "error") {
+			options.onStatus?.(initialStatus);
+			return initialStatus;
+		}
+		if (initialStatus.availability === "available") {
+			options.onStatus?.(initialStatus);
+			return initialStatus;
+		}
+		options.onStatus?.({
+			availability: "downloading",
+			message: "Downloading browser translation support."
+		});
+		(await raceAbort$1(translator.create({
+			sourceLanguage,
+			targetLanguage,
+			signal: options.signal,
+			monitor: (monitor) => monitorDownload(monitor, { setStatus(input) {
+				options.onStatus?.({
+					availability: "downloading",
+					progress: input.progress,
+					message: input.message
+				});
+			} })
+		}), options.signal)).destroy?.();
+		const finalStatus = {
+			availability: "available",
+			message: "Browser translator is ready."
+		};
+		options.onStatus?.(finalStatus);
+		return finalStatus;
+	} catch (error) {
+		if (options.signal.aborted) {
+			const cancelledStatus = {
+				availability: "downloadable",
+				message: "Browser translation download was cancelled."
+			};
+			options.onStatus?.(cancelledStatus);
+			return cancelledStatus;
+		}
+		const failureStatus = {
+			availability: "error",
+			message: getErrorMessage$1(error)
+		};
+		options.onStatus?.(failureStatus);
+		return failureStatus;
+	}
+}
 var BrowserTranslatorFactory = class {
 	constructor(win = window) {
 		this.win = win;
@@ -114783,10 +115321,20 @@ var BrowserTranslatorFactory = class {
 		}), options.signal);
 		return {
 			async *batchTranslate(inputs, batchOptions) {
-				for (const [index, input] of inputs.entries()) yield {
-					index,
-					output: await native.translate(input, batchOptions)
-				};
+				for (const [index, input] of inputs.entries()) {
+					const controlled = await runControlledTranslationTask((signal) => native.translate(input, { signal }), batchOptions);
+					if (controlled.ok) {
+						yield {
+							index,
+							output: controlled.value
+						};
+						continue;
+					}
+					yield {
+						index,
+						error: controlled.error
+					};
+				}
 			},
 			destroy() {
 				native.destroy?.();
@@ -136453,8 +137001,22 @@ buildSearchIndex(SUPPORTED_TRANSLATION_LANGUAGES.map((language) => ({
 //#endregion
 //#region src/lib/browser-translation.ts
 var browserSupportTableCache = /* @__PURE__ */ new Map();
+function isFiniteTranslationOffset(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isTranslationSegmentKind(value) {
+	return value === "heading" || value === "listItem" || value === "paragraph" || value === "blockquote" || value === "text";
+}
 function isRenderableTranslationSegment(segment) {
-	return typeof segment === "object" && segment !== null && !Array.isArray(segment);
+	if (typeof segment !== "object" || segment === null || Array.isArray(segment)) return false;
+	const id = Reflect.get(segment, "id");
+	const sourceStartOffset = Reflect.get(segment, "sourceStartOffset");
+	const sourceEndOffset = Reflect.get(segment, "sourceEndOffset");
+	const sourceKind = Reflect.get(segment, "sourceKind");
+	const source = Reflect.get(segment, "source");
+	const translatorInput = Reflect.get(segment, "translatorInput");
+	const kind = Reflect.get(segment, "kind");
+	return typeof id === "string" && isFiniteTranslationOffset(sourceStartOffset) && isFiniteTranslationOffset(sourceEndOffset) && typeof sourceKind === "string" && typeof source === "string" && typeof translatorInput === "string" && isTranslationSegmentKind(kind);
 }
 function createBrowserTranslationExecution() {
 	return {
@@ -136474,6 +137036,18 @@ var SUPPORTED_TRANSLATION_LANGUAGE_CODES = new Set(SUPPORTED_TRANSLATION_LANGUAG
 function isBrowserTranslationSupported() {
 	return typeof window !== "undefined" && !!window.Translator;
 }
+async function prepareBrowserTranslation(targetLanguage, input) {
+	if (typeof window === "undefined") return {
+		availability: "missing",
+		message: "Browser translation is not available."
+	};
+	return prepareBrowserTranslator(targetLanguage, {
+		sourceLanguage: input.sourceLanguage ?? DEFAULT_SOURCE_LANGUAGE,
+		signal: input.signal,
+		onStatus: input.onStatus,
+		win: window
+	});
+}
 function getBrowserSupportTableState(targetLanguage) {
 	return browserSupportTableCache.get(normalizeBrowserSupportTargetKey(targetLanguage)) ?? null;
 }
@@ -136782,6 +137356,7 @@ async function translateMarkdownDocumentProgressively(args, onPatch) {
 			sourceLanguage,
 			targetLanguage: args.targetLanguage,
 			signal: args.signal,
+			timeoutMs: args.timeoutMs,
 			cache: args.cache,
 			jobs,
 			translatedSegments,
@@ -136867,9 +137442,25 @@ async function translatePendingJobsBySourceLanguage(input) {
 			startWorkersToDesired();
 		}
 	};
-	const applyBatchResult = async (batch, outputs) => {
+	const applyBatchResult = async (batch, result) => {
 		for (const [offset, job] of batch.jobs.entries()) {
-			const target = outputs[offset] ?? "";
+			const error = result.errors.get(offset);
+			if (error) {
+				const failedSegment = {
+					...job.segment,
+					sourceLanguage: job.sourceLanguage,
+					targetLanguage: input.targetLanguage,
+					status: "error",
+					error
+				};
+				input.translatedSegments[job.segmentIndex] = failedSegment;
+				input.onPatch({
+					segmentIndex: job.segmentIndex,
+					segment: failedSegment
+				});
+				continue;
+			}
+			const target = result.outputs.get(offset) ?? "";
 			const restoredTarget = job.segment.placeholderProtocol ? restoreTranslatedPlaceholderFragment(target, job.segment.placeholderProtocol) : { target: job.protectedInput.restore(target).trim() };
 			const translatedSegment = {
 				...job.segment,
@@ -136908,7 +137499,10 @@ async function translatePendingJobsBySourceLanguage(input) {
 					const batch = batches[batchIndex];
 					const startedAt = getCurrentTimeMs();
 					try {
-						await applyBatchResult(batch, await collectBatchTranslationOutputs(translator.batchTranslate(batch.jobs.map((job) => job.protectedInput.text), { signal: input.signal }), batch.jobs.length));
+						await applyBatchResult(batch, await collectBatchTranslationOutputs(translator.batchTranslate(batch.jobs.map((job) => job.protectedInput.text), {
+							signal: input.signal,
+							timeoutMs: input.timeoutMs ?? 15e3
+						}), batch.jobs.length));
 						completedBatches += 1;
 						const elapsedMs = Math.max(1, getCurrentTimeMs() - startedAt);
 						appendTranslationAdaptiveConcurrencyLog({
@@ -136948,6 +137542,83 @@ async function translatePendingJobsBySourceLanguage(input) {
 	startWorkersToDesired();
 	while (workerPromises.size > 0) await Promise.race(workerPromises);
 }
+async function retryTranslationSegment(input) {
+	const engine = input.engine ?? createBrowserTranslationExecution();
+	const sourceLanguage = input.sourceLanguage ?? input.segment.sourceLanguage ?? DEFAULT_SOURCE_LANGUAGE;
+	if (areEquivalentTranslationLanguages(sourceLanguage, input.targetLanguage)) return {
+		...input.segment,
+		target: input.segment.source,
+		sourceLanguage,
+		targetLanguage: input.targetLanguage,
+		status: "translated",
+		error: void 0
+	};
+	const unsupportedLanguagePairMessage = getUnsupportedEngineLanguagePairMessage({
+		engine,
+		sourceLanguage,
+		targetLanguage: input.targetLanguage
+	});
+	if (unsupportedLanguagePairMessage) return {
+		...input.segment,
+		sourceLanguage,
+		targetLanguage: input.targetLanguage,
+		status: "error",
+		error: unsupportedLanguagePairMessage
+	};
+	const cacheKey = createSegmentCacheKey(input.segment, sourceLanguage, input.targetLanguage, engine.cacheIdentity);
+	const cachedSegment = cacheKey ? await readCachedTranslationSegment(input.cache, cacheKey, input.segment, {
+		sourceLanguage,
+		targetLanguage: input.targetLanguage
+	}) : null;
+	if (cachedSegment) return cachedSegment;
+	const protectedInput = input.segment.placeholderProtocol ? {
+		text: input.segment.translatorInput,
+		restore: (output) => output
+	} : protectTranslatorInput(input.segment.translatorInput);
+	let translator = null;
+	try {
+		translator = await engine.factory.create({
+			sourceLanguage,
+			targetLanguage: input.targetLanguage,
+			signal: input.signal
+		});
+		const result = await collectBatchTranslationOutputs(translator.batchTranslate([protectedInput.text], {
+			signal: input.signal,
+			timeoutMs: input.timeoutMs ?? 15e3
+		}), 1);
+		const error = result.errors.get(0);
+		if (error) return {
+			...input.segment,
+			sourceLanguage,
+			targetLanguage: input.targetLanguage,
+			status: "error",
+			error
+		};
+		const target = result.outputs.get(0) ?? "";
+		const restoredTarget = input.segment.placeholderProtocol ? restoreTranslatedPlaceholderFragment(target, input.segment.placeholderProtocol) : { target: protectedInput.restore(target).trim() };
+		const translatedSegment = {
+			...input.segment,
+			...restoredTarget,
+			sourceLanguage,
+			targetLanguage: input.targetLanguage,
+			status: "translated",
+			error: void 0
+		};
+		if (cacheKey) writeCachedTranslationSegment(input.cache, cacheKey, translatedSegment);
+		return translatedSegment;
+	} catch (error) {
+		if (input.signal.aborted) throw error;
+		return {
+			...input.segment,
+			sourceLanguage,
+			targetLanguage: input.targetLanguage,
+			status: "error",
+			error: getErrorMessage(error)
+		};
+	} finally {
+		translator?.destroy?.();
+	}
+}
 function getUnsupportedEngineLanguagePairMessage(input) {
 	if (!isDirectionalManagedLocalTranslationEngineId(input.engine.cacheIdentity.engineId)) return null;
 	const directionCheck = checkLocalDirectionalModelLanguagePair({
@@ -137012,12 +137683,17 @@ function packTranslationJobs(jobs) {
 }
 async function collectBatchTranslationOutputs(stream, expectedCount) {
 	const outputs = /* @__PURE__ */ new Map();
+	const errors = /* @__PURE__ */ new Map();
 	for await (const item of stream) {
 		if (item.index < 0 || item.index >= expectedCount) throw new Error(`Translator yielded output for unexpected index ${item.index}.`);
-		if (!outputs.has(item.index)) outputs.set(item.index, item.output);
+		if (item.output !== void 0 && !outputs.has(item.index)) outputs.set(item.index, item.output);
+		if (item.error && !errors.has(item.index)) errors.set(item.index, item.error.message);
 	}
-	if (outputs.size !== expectedCount) throw new Error(`Translator returned ${outputs.size} outputs for ${expectedCount} inputs.`);
-	return Array.from({ length: expectedCount }, (_, index) => outputs.get(index) ?? "");
+	if (outputs.size + errors.size !== expectedCount) throw new Error(`Translator returned ${outputs.size + errors.size} results for ${expectedCount} inputs.`);
+	return {
+		outputs,
+		errors
+	};
 }
 function estimateTranslationTokens(input) {
 	const trimmed = input.trim();
@@ -137245,6 +137921,7 @@ function toMarkdownFactKindFromHast(tagName) {
 	if (/^h[1-6]$/.test(tagName)) return "heading";
 	if (tagName === "li") return "listItem";
 	if (tagName === "blockquote") return "blockquote";
+	if (tagName === "td" || tagName === "th") return "tableCell";
 	return "paragraph";
 }
 function toTranslationSegmentKindFromHast(tagName) {
@@ -137561,8 +138238,14 @@ function useDocumentTranslationActivation() {
 }
 //#endregion
 //#region src/lib/resolve-document-translation-config.ts
-function resolveDocumentTranslationConfig(translationConfig, globalSettings) {
+function resolveDocumentTranslationConfig(translationConfig, globalSettings, configPresence) {
 	if (!translationConfig) return void 0;
+	const translationPresence = configPresence?.translation;
+	const projectOwnsEnabled = translationPresence?.enabled ?? false;
+	const projectOwnsTargetLanguage = translationPresence?.targetLanguage ?? false;
+	const projectOwnsDisplayMode = translationPresence?.displayMode ?? false;
+	const projectOwnsCacheEnabled = translationPresence?.cacheEnabled ?? false;
+	const projectOwnsEngineId = translationPresence?.engineId ?? false;
 	const local = translationConfig.engines?.local ?? {};
 	const localCt2 = translationConfig.engines?.localCt2 ?? {};
 	const localLlama = translationConfig.engines?.localLlama ?? {};
@@ -137576,6 +138259,11 @@ function resolveDocumentTranslationConfig(translationConfig, globalSettings) {
 	const resolvedOpenAIModel = openai.model ?? globalSettings?.translationEngines.openai?.model;
 	return {
 		...translationConfig,
+		enabled: projectOwnsEnabled ? translationConfig.enabled : globalSettings?.translation?.enabled ?? translationConfig.enabled,
+		targetLanguage: projectOwnsTargetLanguage ? translationConfig.targetLanguage : globalSettings?.translation?.targetLanguage ?? translationConfig.targetLanguage,
+		displayMode: projectOwnsDisplayMode ? translationConfig.displayMode : globalSettings?.translation?.displayMode ?? translationConfig.displayMode,
+		cacheEnabled: projectOwnsCacheEnabled ? translationConfig.cacheEnabled : globalSettings?.translation?.cacheEnabled ?? translationConfig.cacheEnabled,
+		engineId: projectOwnsEngineId ? translationConfig.engineId : globalSettings?.translationEngines.engineId ?? translationConfig.engineId,
 		engines: {
 			local: {
 				...local,
@@ -137646,12 +138334,20 @@ function projectTranslateServiceStatus(input) {
 			message: input.browserCapabilityLoading ? "Browser translation capability is being checked." : "Browser translator will be checked before translation starts."
 		};
 		switch (input.browserCapability.availability) {
-			case "available":
-			case "downloadable":
+			case "available": return {
+				state: "ready",
+				engineId: "browser",
+				message: input.browserCapability.message ?? "Browser translator is ready."
+			};
+			case "downloadable": return {
+				state: "ready",
+				engineId: "browser",
+				message: input.browserCapability.message ?? "Browser translation support will be downloaded when translation starts."
+			};
 			case "downloading": return {
 				state: "ready",
 				engineId: "browser",
-				message: "Browser translator is ready."
+				message: input.browserCapability.message ?? "Browser translation support is downloading and will continue when ready."
 			};
 			case "missing":
 			case "unavailable":
@@ -137673,6 +138369,11 @@ function projectTranslateServiceStatus(input) {
 			engineId: input.engineId,
 			message: getTranslationEngineLifecycleMessage(input.engineLifecycle) ?? "Translation engine runtime is not ready."
 		};
+		if (input.engineLifecycle.assets.state === "error") return {
+			state: "unavailable",
+			engineId: input.engineId,
+			message: input.engineLifecycle.assets.message ?? input.engineLifecycle.assets.error ?? "Selected local model is incompatible with the current translation runtime."
+		};
 	}
 	if (isManagedLocalTranslationEngineId(input.engineId)) {
 		if (!input.localModel?.trim()) return {
@@ -137715,6 +138416,7 @@ function isLocalAssetReady(asset, selectedGroupId) {
 }
 //#endregion
 //#region src/lib/translate-service.ts
+var DEFAULT_BROWSER_SOURCE_LANGUAGE = "en";
 async function resolveTranslateServiceState(input) {
 	const config = input.config;
 	if (!config?.enabled || !input.hasSource) return emitTranslateServiceState(input.onUpdate, { status: projectTranslateServiceStatus({
@@ -137876,7 +138578,7 @@ function prepareTranslateServiceRun(input) {
 		hasSource: input.hasSource,
 		engineId: input.config.engineId
 	}) });
-	const preferredRow = input.browserSupportTable?.table?.rows.find((row) => row.availability === "available") ?? input.browserSupportTable?.table?.rows.find((row) => row.availability === "downloading") ?? input.browserSupportTable?.table?.rows.find((row) => row.availability === "downloadable") ?? null;
+	const preferredRow = selectPreferredBrowserSupportRow(input.browserSupportTable);
 	if (!preferredRow) return createTranslateServiceState({
 		browserSupportTable: input.browserSupportTable,
 		status: projectTranslateServiceStatus({
@@ -137904,6 +138606,51 @@ function prepareTranslateServiceRun(input) {
 		})
 	});
 }
+async function ensureBrowserTranslationReady(input) {
+	const preferredRow = selectPreferredBrowserSupportRow(input.browserSupportTable, input.sourceLanguage);
+	const sourceLanguage = input.sourceLanguage?.trim() || preferredRow?.sourceLanguage || DEFAULT_BROWSER_SOURCE_LANGUAGE;
+	if (!sourceLanguage) throw new Error("No browser translation language pair is available to prepare.");
+	if (preferredRow?.availability === "available" && normalizeBrowserLanguageTag(preferredRow.sourceLanguage) === normalizeBrowserLanguageTag(sourceLanguage)) return {
+		capability: {
+			availability: "available",
+			message: preferredRow.message
+		},
+		browserSupportTable: input.browserSupportTable,
+		sourceLanguage
+	};
+	let nextTable = input.browserSupportTable;
+	const emit = (capability) => {
+		nextTable = patchBrowserSupportTableRow(input.targetLanguage, {
+			sourceLanguage,
+			targetLanguage: input.targetLanguage,
+			availability: capability.availability,
+			progress: capability.progress,
+			message: capability.message
+		}, { state: capability.availability === "error" ? "error" : "ready" });
+		input.onUpdate?.({
+			capability,
+			browserSupportTable: nextTable,
+			sourceLanguage
+		});
+	};
+	const finalStatus = await prepareBrowserTranslation(input.targetLanguage, {
+		sourceLanguage,
+		signal: input.signal ?? new AbortController().signal,
+		onStatus: emit
+	});
+	if (input.signal?.aborted) throw new DOMException("The operation was aborted.", "AbortError");
+	if (finalStatus.availability !== "available") throw new Error(finalStatus.message ?? "Browser translator is not ready.");
+	const readyCapability = {
+		availability: "available",
+		message: finalStatus.message
+	};
+	emit(readyCapability);
+	return {
+		capability: readyCapability,
+		browserSupportTable: nextTable,
+		sourceLanguage
+	};
+}
 function createTranslationEngineExecution(config) {
 	if (config.engineId === "browser" || isStaticMode()) return createBrowserTranslationExecution();
 	const model = config.engineId === "openai" ? config.engines.openai.model : getManagedLocalEngineConfig(config).model;
@@ -137945,6 +138692,18 @@ function getManagedLocalEngineConfig(config) {
 		selectedGroupId: config.engines.local.selectedGroupId
 	};
 }
+function selectPreferredBrowserSupportRow(browserSupportTable, sourceLanguage) {
+	const rows = browserSupportTable?.table?.rows ?? [];
+	if (sourceLanguage) {
+		const normalizedSourceLanguage = normalizeBrowserLanguageTag(sourceLanguage);
+		const matchingRow = rows.find((row) => normalizeBrowserLanguageTag(row.sourceLanguage) === normalizedSourceLanguage);
+		if (matchingRow) return matchingRow;
+	}
+	return rows.find((row) => row.availability === "available") ?? rows.find((row) => row.availability === "downloading") ?? rows.find((row) => row.availability === "downloadable") ?? null;
+}
+function normalizeBrowserLanguageTag(language) {
+	return language.trim().toLowerCase();
+}
 async function queryManagedLocalPanelState(engineId, input) {
 	return engineId === "local" ? trpcClient.localModels.panelState.query(input) : engineId === "local-ct2" ? trpcClient.localCt2Models.panelState.query(input) : trpcClient.localLlamaModels.panelState.query(input);
 }
@@ -137965,7 +138724,8 @@ var TrpcTranslator = class {
 			selectedGroupId: this.options.selectedGroupId,
 			inputs,
 			instructions: options?.instructions,
-			context: options?.context
+			context: options?.context,
+			timeoutMs: options?.timeoutMs ?? 15e3
 		}, {
 			onData(event) {
 				queue.push(event);
@@ -138044,8 +138804,6 @@ function useDocumentTranslation(markdown, config) {
 	(0, import_react.useEffect)(() => reset, [reset]);
 	(0, import_react.useEffect)(() => {
 		generationRef.current += 1;
-		setCapability(null);
-		setBrowserSupportTable(null);
 		segmentPatchMapRef.current.clear();
 		setResult(null);
 		setStatus("source");
@@ -138064,6 +138822,21 @@ function useDocumentTranslation(markdown, config) {
 		config?.engines.openai.model,
 		config?.targetLanguage
 	]);
+	(0, import_react.useEffect)(() => {
+		setCapability(null);
+		setBrowserSupportTable(null);
+	}, [
+		config?.enabled,
+		config?.engineId,
+		config?.engines.local.model,
+		config?.engines.local.selectedGroupId,
+		config?.engines.localCt2.model,
+		config?.engines.localCt2.selectedGroupId,
+		config?.engines.localLlama.model,
+		config?.engines.localLlama.selectedGroupId,
+		config?.engines.openai.model,
+		config?.targetLanguage
+	]);
 	(0, import_react.useEffect)(() => {
 		let disposed = false;
 		const controller = new AbortController();
@@ -138118,6 +138891,7 @@ function useDocumentTranslation(markdown, config) {
 		segmentPatchMapRef.current.clear();
 		setError(null);
 		setStatus("initializing");
+		let restoreServiceStatus = null;
 		try {
 			if (serviceStatus.state !== "ready") {
 				setError(serviceStatus.message);
@@ -138138,6 +138912,30 @@ function useDocumentTranslation(markdown, config) {
 					setStatus("unavailable");
 					return;
 				}
+				restoreServiceStatus = nextState.status;
+				const preparedState = await ensureBrowserTranslationReady({
+					targetLanguage: config.targetLanguage,
+					browserSupportTable: nextState.browserSupportTable,
+					signal: controller.signal,
+					onUpdate: (browserState) => {
+						if (controller.signal.aborted || abortRef.current !== controller || generationRef.current !== generationId) return;
+						setCapability(browserState.capability);
+						setBrowserSupportTable(browserState.browserSupportTable);
+						setServiceStatus(browserState.capability.availability === "available" ? nextState.status : {
+							state: "checking",
+							engineId: "browser",
+							message: browserState.capability.message ?? "Preparing browser translation support."
+						});
+					}
+				});
+				if (controller.signal.aborted || abortRef.current !== controller || generationRef.current !== generationId) return;
+				setCapability(preparedState.capability);
+				setBrowserSupportTable(preparedState.browserSupportTable);
+				setServiceStatus({
+					state: "ready",
+					engineId: "browser",
+					message: preparedState.capability.message ?? "Browser translator is ready."
+				});
 			}
 			setStatus("translating");
 			setResult({
@@ -138150,6 +138948,7 @@ function useDocumentTranslation(markdown, config) {
 				targetLanguage: config.targetLanguage,
 				displayMode: config.displayMode,
 				signal: controller.signal,
+				timeoutMs: DEFAULT_BATCH_TRANSLATION_TIMEOUT_MS,
 				engine: createTranslationEngineExecution(config),
 				cache: config.cacheEnabled && !isStaticMode() ? {
 					read: (keyHash) => trpcClient.translationCache.read.query({ keyHash }),
@@ -138173,6 +138972,10 @@ function useDocumentTranslation(markdown, config) {
 			setStatus("translated");
 		} catch (translationError) {
 			if (controller.signal.aborted || abortRef.current !== controller || generationRef.current !== generationId) return;
+			if (restoreServiceStatus?.engineId === "browser") {
+				const fallbackServiceStatus = restoreServiceStatus;
+				setServiceStatus((current) => current.state === "checking" ? fallbackServiceStatus : current);
+			}
 			setError(translationError instanceof Error ? translationError.message : "Translation failed.");
 			setStatus("error");
 		} finally {
@@ -138195,6 +138998,100 @@ function useDocumentTranslation(markdown, config) {
 		markdown,
 		serviceStatus
 	]);
+	const retrySegment = (0, import_react.useCallback)(async (segmentId) => {
+		if (!config?.enabled || !result) return;
+		const segmentIndex = result.segments.findIndex((segment) => segment.id === segmentId);
+		const segment = result.segments[segmentIndex];
+		if (segmentIndex < 0 || !segment || segment.status !== "error") return;
+		const controller = new AbortController();
+		let restoreServiceStatus = null;
+		const retryingSegment = {
+			...segment,
+			error: void 0,
+			status: "pending"
+		};
+		setResult((current) => current ? {
+			...current,
+			segments: current.segments.map((entry, index) => index === segmentIndex ? retryingSegment : entry)
+		} : current);
+		try {
+			if (config.engineId === "browser") {
+				restoreServiceStatus = {
+					state: "ready",
+					engineId: "browser",
+					message: capability?.message ?? "Browser translator is ready."
+				};
+				const preparedState = await ensureBrowserTranslationReady({
+					targetLanguage: config.targetLanguage,
+					sourceLanguage: segment.sourceLanguage,
+					browserSupportTable,
+					signal: controller.signal,
+					onUpdate: (browserState) => {
+						setCapability(browserState.capability);
+						setBrowserSupportTable(browserState.browserSupportTable);
+						setServiceStatus(browserState.capability.availability === "available" ? {
+							state: "ready",
+							engineId: "browser",
+							message: browserState.capability.message ?? "Browser translator is ready."
+						} : {
+							state: "checking",
+							engineId: "browser",
+							message: browserState.capability.message ?? "Preparing browser translation support."
+						});
+					}
+				});
+				setCapability(preparedState.capability);
+				setBrowserSupportTable(preparedState.browserSupportTable);
+				setServiceStatus({
+					state: "ready",
+					engineId: "browser",
+					message: preparedState.capability.message ?? "Browser translator is ready."
+				});
+			}
+			const nextSegment = await retryTranslationSegment({
+				segment,
+				sourceLanguage: segment.sourceLanguage,
+				targetLanguage: config.targetLanguage,
+				signal: controller.signal,
+				timeoutMs: DEFAULT_BATCH_TRANSLATION_TIMEOUT_MS,
+				engine: createTranslationEngineExecution(config),
+				cache: config.cacheEnabled && !isStaticMode() ? {
+					read: (keyHash) => trpcClient.translationCache.read.query({ keyHash }),
+					write: (input) => trpcClient.translationCache.write.mutate(input)
+				} : void 0
+			});
+			setResult((current) => current ? {
+				...current,
+				segments: current.segments.map((entry, index) => index === segmentIndex ? nextSegment : entry)
+			} : current);
+			setError((current) => {
+				if (nextSegment.status === "error") return nextSegment.error ?? current;
+				return getDocumentTranslationFailureMessage(buildRetriedDocumentResult(result, segmentIndex, nextSegment));
+			});
+			setStatus((current) => {
+				if (nextSegment.status === "error") return current === "translated" ? "translated" : "error";
+				return getDocumentTranslationFailureMessage(buildRetriedDocumentResult(result, segmentIndex, nextSegment)) ? "error" : "translated";
+			});
+		} catch (retryError) {
+			if (restoreServiceStatus?.engineId === "browser") {
+				const fallbackServiceStatus = restoreServiceStatus;
+				setServiceStatus((current) => current.state === "checking" ? fallbackServiceStatus : current);
+			}
+			setResult((current) => current ? {
+				...current,
+				segments: current.segments.map((entry, index) => index === segmentIndex ? {
+					...segment,
+					status: "error",
+					error: retryError instanceof Error ? retryError.message : "Translation retry failed."
+				} : entry)
+			} : current);
+		}
+	}, [
+		browserSupportTable,
+		capability?.message,
+		config,
+		result
+	]);
 	(0, import_react.useEffect)(() => {
 		latestStartRef.current = start;
 	}, [start]);
@@ -138202,10 +139099,14 @@ function useDocumentTranslation(markdown, config) {
 		if (activation !== "translated" || !config?.enabled || markdown.length === 0) return;
 		if (status !== "source") return;
 		if (serviceStatus.state !== "ready") return;
+		if (config.engineId === "browser" && !canAutoStartBrowserTranslation(capability, browserSupportTable)) return;
 		latestStartRef.current?.();
 	}, [
 		activation,
+		browserSupportTable,
+		capability,
 		config?.enabled,
+		config?.engineId,
 		markdown.length,
 		serviceStatus.state,
 		status
@@ -138217,12 +139118,13 @@ function useDocumentTranslation(markdown, config) {
 		error,
 		result,
 		start,
+		retrySegment,
 		cancel,
 		reset
 	};
 }
 function isDocumentTranslationSegment(segment) {
-	return typeof segment === "object" && segment !== null && !Array.isArray(segment);
+	return isRenderableTranslationSegment(segment);
 }
 function getDocumentTranslationFailureMessage(result) {
 	const segments = (Array.isArray(result.segments) ? result.segments : []).filter(isDocumentTranslationSegment);
@@ -138250,6 +139152,16 @@ function normalizeDocumentTranslationResult(result) {
 		segments: (Array.isArray(result.segments) ? result.segments : []).filter(isDocumentTranslationSegment)
 	};
 }
+function buildRetriedDocumentResult(current, segmentIndex, nextSegment) {
+	return normalizeDocumentTranslationResult({
+		...current,
+		segments: current.segments.map((entry, index) => index === segmentIndex ? nextSegment : entry)
+	});
+}
+function canAutoStartBrowserTranslation(capability, browserSupportTable) {
+	if (capability?.availability === "available") return true;
+	return (browserSupportTable?.table?.rows ?? []).some((row) => row.availability === "available");
+}
 //#endregion
 //#region ../../node_modules/.pnpm/comma-separated-tokens@2.0.3/node_modules/comma-separated-tokens/index.js
 /**
@@ -148659,15 +149571,21 @@ function createAnnotationComponents(inlineAnnotations, blockAnnotationByOffset)
 			});
 		},
 		th: ({ children, node, ...props }) => {
+			const annotation = getBlockAnnotation(node, blockAnnotationByOffset, "tableCell");
 			return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("th", {
 				...props,
-				children: render(children)
+				...annotation?.dataAttributes,
+				className: mergeClassName$2(props.className, annotation?.className),
+				children: renderBlockChildren(children, annotation)
 			});
 		},
 		td: ({ children, node, ...props }) => {
+			const annotation = getBlockAnnotation(node, blockAnnotationByOffset, "tableCell");
 			return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("td", {
 				...props,
-				children: render(children)
+				...annotation?.dataAttributes,
+				className: mergeClassName$2(props.className, annotation?.className),
+				children: renderBlockChildren(children, annotation)
 			});
 		}
 	};
@@ -148739,7 +149657,7 @@ function CodeBlock({ children, className, title }) {
 		isInline
 	]);
 	if (isInline) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", {
-		className: "bg-muted text-foreground rounded px-1.5 py-0.5 font-mono text-sm",
+		className: "text-foreground rounded px-1 font-mono text-sm [box-shadow:0_1px_0px_var(--primary)]",
 		title,
 		children: code
 	});
@@ -148855,8 +149773,9 @@ function transformSafeMarkdownUrl(value) {
 }
 //#endregion
 //#region src/components/document-translation-segment-render.tsx
-function renderTranslationSegmentChildren({ sourceChildren, segment, displayMode, targetChildren, className }) {
+function renderTranslationSegmentChildren({ sourceChildren, segment, displayMode, targetChildren, className, onRetry }) {
 	const target = segment.target ?? "";
+	const showRetry = segment.status === "error" && typeof onRetry === "function";
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", {
 		className: mergeClassName$1("document-translation-segment", className),
 		children: [displayMode === "bilingual" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
@@ -148869,7 +149788,19 @@ function renderTranslationSegmentChildren({ sourceChildren, segment, displayMode
 			title: displayMode === "direct" ? segment.source : void 0,
 			lang: segment.targetLanguage,
 			"data-translation-target": "",
-			children: targetChildren ?? (segment.targetNodes ? renderTranslatedHastNodes(segment.targetNodes) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MarkdownInlineContent, { markdown: target }))
+			children: showRetry ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", {
+				className: "inline-flex items-center gap-2",
+				children: [displayMode === "direct" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+					className: "text-muted-foreground",
+					children: segment.source
+				}) : null, /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button, {
+					size: "sm",
+					variant: "secondary",
+					"aria-label": "Retry translation",
+					onClick: () => onRetry(segment.id),
+					children: "Retry"
+				})]
+			}) : targetChildren ?? (segment.targetNodes ? renderTranslatedHastNodes(segment.targetNodes) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MarkdownInlineContent, { markdown: target }))
 		})]
 	});
 }
@@ -148894,13 +149825,13 @@ var OPENSPEC_SECTION_TARGET_LABELS = {
 	overview: "目的",
 	requirements: "需求"
 };
-function createTranslatedOpenSpecHeadingProjection(input, segment, displayMode) {
+function createTranslatedOpenSpecHeadingProjection(input, segment, displayMode, onRetry) {
 	const kind = getCurrentDataAttribute(input, "data-openspec-kind");
-	if (kind === "section") return createTranslatedOpenSpecSectionHeadingProjection(input, segment, displayMode);
+	if (kind === "section") return createTranslatedOpenSpecSectionHeadingProjection(input, segment, displayMode, onRetry);
 	if (kind !== "requirement" && kind !== "scenario") return void 0;
-	return createTranslatedOpenSpecStructureHeadingProjection(input, segment, displayMode, kind);
+	return createTranslatedOpenSpecStructureHeadingProjection(input, segment, displayMode, kind, onRetry);
 }
-function createTranslatedOpenSpecSectionHeadingProjection(input, segment, displayMode) {
+function createTranslatedOpenSpecSectionHeadingProjection(input, segment, displayMode, onRetry) {
 	const sectionKind = getCurrentDataAttribute(input, "data-openspec-section-kind");
 	if (!sectionKind) return void 0;
 	const targetTitle = OPENSPEC_SECTION_TARGET_LABELS[sectionKind];
@@ -148918,11 +149849,12 @@ function createTranslatedOpenSpecSectionHeadingProjection(input, segment, displa
 			},
 			displayMode,
 			targetChildren: targetTitle,
-			className: "document-translation-heading-segment"
+			className: "document-translation-heading-segment",
+			onRetry
 		})
 	};
 }
-function createTranslatedOpenSpecStructureHeadingProjection(input, segment, displayMode, kind) {
+function createTranslatedOpenSpecStructureHeadingProjection(input, segment, displayMode, kind, onRetry) {
 	const sourceParts = splitOpenSpecHeadingText(segment.source, kind);
 	const targetParts = splitOpenSpecHeadingText(segment.target ?? "", kind);
 	const visualLabel = getCurrentDataAttribute(input, "data-openspec-visual-label") ?? getCurrentDataAttribute(input, "data-openspec-label");
@@ -148967,7 +149899,8 @@ function createTranslatedOpenSpecStructureHeadingProjection(input, segment, disp
 				segment: titleSegment,
 				displayMode,
 				targetChildren: targetNodes ? renderTranslatedHastNodes(targetNodes) : void 0,
-				className: "document-translation-heading-segment"
+				className: "document-translation-heading-segment",
+				onRetry
 			})
 		})] }),
 		target: targetTitle
@@ -149028,7 +149961,7 @@ function useDocumentTranslationRenderPlugin({ markdown, translationConfig }) {
 	const resolvedTranslationConfig = (0, import_react.useMemo)(() => translationConfig === void 0 ? void 0 : DocumentTranslationConfigSchema.parse(resolveDocumentTranslationConfig(translationConfig, globalSettings)), [globalSettings, translationConfig]);
 	const session = useDocumentTranslation(markdown ?? "", resolvedTranslationConfig);
 	const canTranslate = resolvedTranslationConfig !== void 0 && typeof markdown === "string" && markdown.length > 0;
-	const translationProjection = (0, import_react.useMemo)(() => createTranslationProjection(session.result), [session.result]);
+	const translationProjection = (0, import_react.useMemo)(() => createTranslationProjection(session.result, session.retrySegment), [session.result, session.retrySegment]);
 	const translationAction = (0, import_react.useMemo)(() => canTranslate ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DocumentTranslationAction, {
 		enabled: resolvedTranslationConfig?.enabled ?? false,
 		session
@@ -149099,7 +150032,7 @@ function hashString(value) {
 	for (let index = 0; index < value.length; index++) hash = hash * 31 + value.charCodeAt(index) | 0;
 	return hash.toString(36);
 }
-function createTranslationProjection(result) {
+function createTranslationProjection(result, onRetrySegment) {
 	if (!result) return { blockAnnotations: [] };
 	const segments = getRenderableTranslationSegments(result);
 	const segmentByOffset = new Map(segments.filter((segment) => segment.target).map((segment) => [segment.sourceStartOffset, segment]));
@@ -149121,7 +150054,7 @@ function createTranslationProjection(result) {
 			transformHeading(input) {
 				const segment = input.sourceStartOffset === void 0 ? void 0 : segmentByOffset.get(input.sourceStartOffset);
 				if (!segment?.target || segment.kind !== "heading") return void 0;
-				return createTranslatedHeadingTransform(input, segment, result.displayMode);
+				return createTranslatedHeadingTransform(input, segment, result.displayMode, onRetrySegment);
 			}
 		},
 		blockAnnotations: segments.filter((segment) => segment.target && segment.kind !== "heading").map((segment) => ({
@@ -149140,7 +150073,8 @@ function createTranslationProjection(result) {
 			renderChildren: (children) => segment.targetNodes && result.displayMode === "direct" ? children : renderTranslationSegmentChildren({
 				sourceChildren: children,
 				segment,
-				displayMode: result.displayMode
+				displayMode: result.displayMode,
+				onRetry: onRetrySegment
 			})
 		}))
 	};
@@ -149148,9 +150082,9 @@ function createTranslationProjection(result) {
 function getRenderableTranslationSegments(result) {
 	return (Array.isArray(result.segments) ? result.segments : []).filter(isRenderableTranslationSegment);
 }
-function createTranslatedHeadingTransform(input, segment, displayMode) {
+function createTranslatedHeadingTransform(input, segment, displayMode, onRetrySegment) {
 	const projectedTarget = segment.target ?? "";
-	const openSpecHeading = createTranslatedOpenSpecHeadingProjection(input, segment, displayMode);
+	const openSpecHeading = createTranslatedOpenSpecHeadingProjection(input, segment, displayMode, onRetrySegment);
 	if (openSpecHeading) return {
 		tocDataLabel: displayMode === "direct" ? openSpecHeading.tocDataLabel : input.current?.tocLabel ?? input.text,
 		children: openSpecHeading.children,
@@ -149165,7 +150099,8 @@ function createTranslatedHeadingTransform(input, segment, displayMode) {
 			segment,
 			displayMode,
 			targetChildren,
-			className: "document-translation-heading-segment"
+			className: "document-translation-heading-segment",
+			onRetry: onRetrySegment
 		}),
 		dataAttributes: createTranslationDataAttributes(segment, projectedTarget, displayMode)
 	};
@@ -149176,7 +150111,8 @@ function createTranslatedHeadingTransform(input, segment, displayMode) {
 			segment,
 			displayMode,
 			targetChildren,
-			className: "document-translation-heading-segment"
+			className: "document-translation-heading-segment",
+			onRetry: onRetrySegment
 		}),
 		dataAttributes: createTranslationDataAttributes(segment, projectedTarget, displayMode)
 	};