dsh-diff-approval 0.17.0 → 0.19.0

package/lib/index.js

@@ -1,5 +1,5 @@
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve, sep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { dshHomePath, expandHomePath } from "@deepseek-ai/dsh-home-paths";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { spawn } from "node:child_process";
@@ -738,6 +738,12 @@ function detectEol(text) {
 function normalizeEol(text) {
 	return text.replace(/\r\n?/g, "\n");
 }
+/** Whether two contents are equal ignoring line endings and a trailing-newline
+*  difference — the same tolerance the whole-file diff uses, so a file that the
+*  diff view shows as "no pending diff" is treated as fully resolved here too. */
+function contentEqual(a, b) {
+	return contentLinesOf(normalizeEol(a)).join("\n") === contentLinesOf(normalizeEol(b)).join("\n");
+}
 /** Re-encode `text`'s line endings to `eol` (its content is unchanged). */
 function reencodeEol(text, eol) {
 	const normalized = normalizeEol(text);
@@ -813,6 +819,26 @@ function sessionOfAgent(agent) {
 	return typeof id === "string" && id.length > 0 ? SessionId(id) : void 0;
 }
 /**
+* The MIME type for an image path by its lowercased extension. An unknown or
+* non-image extension falls back to the generic binary type, which browsers
+* still render when the bytes decode; the common Markdown image formats are
+* covered so a preview inlines as the right content type.
+* @param path - the image's OS path.
+* @returns the MIME type.
+*/
+function imageMimeOf(path) {
+	const lower = path.toLowerCase();
+	if (lower.endsWith(".png")) return "image/png";
+	if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+	if (lower.endsWith(".gif")) return "image/gif";
+	if (lower.endsWith(".webp")) return "image/webp";
+	if (lower.endsWith(".svg")) return "image/svg+xml";
+	if (lower.endsWith(".avif")) return "image/avif";
+	if (lower.endsWith(".bmp")) return "image/bmp";
+	if (lower.endsWith(".ico")) return "image/x-icon";
+	return "application/octet-stream";
+}
+/**
 * Build one channel error in the closed RPC error vocabulary. `internal` is
 * the catch-all: business misses ride the success branch as `outcome: 'missing'`.
 * @param message - the handler-side description.
@@ -1102,6 +1128,40 @@ function apply(ctx, config) {
 		const policy = sandboxPolicyOf(sessionId);
 		return policy === void 0 ? ctx.fs.writeText(target, content, void 0, signal) : ctx.fs.writeText(target, content, void 0, signal, policy);
 	}
+	/**
+	* Revert one entry's file back to its baseline (the shared per-entry logic
+	* behind both the single `revert` endpoint and the bulk `revert-all`). A
+	* created file's revert deletes it (not undoable: the file is gone), an edit
+	* writes the baseline back and yields the before/after undo snapshot.
+	* @param entry - the entry to revert.
+	* @param sessionId - the entry's session (for the per-session write policy).
+	* @param signal - aborts before atomic publication takes effect.
+	* @returns the undo snapshot, or `undefined` when the revert is not undoable.
+	*/
+	async function revertEntryContent(entry, sessionId, signal) {
+		const resolved = await ctx.fs.resolve(entry.path, { signal });
+		if (entry.kind === "create") {
+			await rm(ctx.fs.processPath(resolved), { force: true });
+			return;
+		}
+		const preWrite = await ctx.fs.readText(resolved, void 0) ?? entry.newText;
+		const content = reencodeEol(entry.oldText, detectEol(entry.newText));
+		await writeRevert(resolved, content, sessionId, signal);
+		return {
+			before: {
+				id: entry.id,
+				path: entry.path,
+				entry,
+				fileText: preWrite
+			},
+			after: {
+				id: entry.id,
+				path: entry.path,
+				entry: void 0,
+				fileText: content
+			}
+		};
+	}
 	const undoStack = [];
 	const redoStack = [];
 	function pushUndo(sessionId, before, after) {
@@ -1264,27 +1324,7 @@ function apply(ctx, config) {
 				}
 				let undo;
 				try {
-					const resolved = await ctx.fs.resolve(entry.path, { signal });
-					if (entry.kind === "create") await rm(ctx.fs.processPath(resolved), { force: true });
-					else {
-						const preWrite = await ctx.fs.readText(resolved, void 0) ?? entry.newText;
-						const content = reencodeEol(entry.oldText, detectEol(entry.newText));
-						await writeRevert(resolved, content, target.sessionId, signal);
-						undo = {
-							before: {
-								id: entry.path,
-								path: entry.path,
-								entry,
-								fileText: preWrite
-							},
-							after: {
-								id: entry.path,
-								path: entry.path,
-								entry: void 0,
-								fileText: content
-							}
-						};
-					}
+					undo = await revertEntryContent(entry, target.sessionId, signal);
 				} catch (error) {
 					return rpcError(`revert failed: ${errorMessage(error)}`);
 				}
@@ -1296,6 +1336,86 @@ function apply(ctx, config) {
 					value: { outcome: "reverted" }
 				};
 			}
+			case "keep-all": {
+				const sessionId = sessionOf(payload);
+				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
+				await ensureLoaded();
+				const entries = store.list(sessionId);
+				const before = [];
+				const after = [];
+				for (const entry of entries) {
+					before.push({
+						id: entry.id,
+						path: entry.path,
+						entry,
+						fileText: void 0
+					});
+					after.push({
+						id: entry.id,
+						path: entry.path,
+						entry: void 0,
+						fileText: void 0
+					});
+					store.remove(entry.id);
+				}
+				if (before.length > 0) pushUndo(sessionId, {
+					id: before[0].id,
+					path: before[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: before
+				}, {
+					id: after[0].id,
+					path: after[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: after
+				});
+				persistSession(true);
+				return {
+					ok: true,
+					value: { affected: before.length }
+				};
+			}
+			case "revert-all": {
+				const sessionId = sessionOf(payload);
+				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
+				await ensureLoaded();
+				const entries = store.list(sessionId);
+				const batchBefore = [];
+				const batchAfter = [];
+				for (const entry of entries) {
+					let undo;
+					try {
+						undo = await revertEntryContent(entry, sessionId, signal);
+					} catch {
+						return rpcError(`revert-all failed for ${entry.path}`);
+					}
+					if (undo !== void 0) {
+						batchBefore.push(undo.before);
+						batchAfter.push(undo.after);
+					}
+					store.remove(entry.id);
+				}
+				if (batchBefore.length > 0) pushUndo(sessionId, {
+					id: batchBefore[0].id,
+					path: batchBefore[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: batchBefore
+				}, {
+					id: batchAfter[0].id,
+					path: batchAfter[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: batchAfter
+				});
+				persistSession(true);
+				return {
+					ok: true,
+					value: { affected: entries.length }
+				};
+			}
 			case "block-keep": {
 				const blockTarget = blockTargetOf(payload);
 				if (blockTarget === void 0) return rpcError("sessionId, id, and block must be valid");
@@ -1325,9 +1445,25 @@ function apply(ctx, config) {
 					fileText: void 0
 				});
 				persistSession();
+				const fullyResolved = contentEqual(updatedOld, entry.newText);
+				if (fullyResolved && blockTarget.removeWhenResolved === true) {
+					store.remove(blockTarget.id);
+					pushUndo(blockTarget.sessionId, {
+						id: entry.id,
+						path: entry.path,
+						entry: afterEntry,
+						fileText: void 0
+					}, {
+						id: entry.id,
+						path: entry.path,
+						entry: void 0,
+						fileText: void 0
+					});
+					persistSession(true);
+				}
 				return {
 					ok: true,
-					value: updatedOld === entry.newText ? {
+					value: fullyResolved ? {
 						outcome: "kept",
 						resolved: true
 					} : { outcome: "kept" }
@@ -1378,9 +1514,25 @@ function apply(ctx, config) {
 				}
 				if (undo !== void 0) pushUndo(blockTarget.sessionId, undo.before, undo.after);
 				persistSession();
+				const fullyResolved = contentEqual(updatedNew, entry.oldText);
+				if (fullyResolved && blockTarget.removeWhenResolved === true) {
+					store.remove(blockTarget.id);
+					pushUndo(blockTarget.sessionId, {
+						id: entry.id,
+						path: entry.path,
+						entry: afterEntry,
+						fileText: void 0
+					}, {
+						id: entry.id,
+						path: entry.path,
+						entry: void 0,
+						fileText: void 0
+					});
+					persistSession(true);
+				}
 				return {
 					ok: true,
-					value: normalizeEol(updatedNew) === normalizeEol(entry.oldText) ? {
+					value: fullyResolved ? {
 						outcome: "reverted",
 						resolved: true
 					} : { outcome: "reverted" }
@@ -1549,6 +1701,29 @@ function apply(ctx, config) {
 					value: { outcome: "opened" }
 				};
 			}
+			case "preview-image": {
+				const image = previewImageTargetOf(payload);
+				if (image === void 0) return rpcError("sessionId and path must be valid");
+				await ensureLoaded();
+				const workspace = workspaceOf(image.sessionId);
+				if (workspace === void 0) return rpcError("image unavailable: the session has no workspace");
+				let dataUri;
+				try {
+					const target = await ctx.fs.resolve(image.path, { signal });
+					const workspaceTarget = await ctx.fs.resolve(workspace.path, {});
+					const osPath = ctx.fs.processPath(target);
+					const workspaceOs = ctx.fs.processPath(workspaceTarget);
+					const inside = relative(workspaceOs, osPath);
+					if (inside !== "" && !inside.startsWith("..") && !isAbsolute(inside)) {
+						const bytes = await readFile(osPath);
+						if (bytes.length > 0) dataUri = `data:${imageMimeOf(osPath)};base64,${bytes.toString("base64")}`;
+					}
+				} catch {}
+				return {
+					ok: true,
+					value: { dataUri }
+				};
+			}
 			default: return rpcError(`unknown endpoint ${JSON.stringify(endpoint)}`);
 		}
 	};
@@ -1625,6 +1800,7 @@ function blockTargetOf(payload) {
 		newStart,
 		newEnd
 	].every((value) => typeof value === "number" && Number.isFinite(value))) return void 0;
+	const removeWhenResolved = payload.removeWhenResolved;
 	return {
 		...target,
 		block: {
@@ -1632,7 +1808,8 @@ function blockTargetOf(payload) {
 			oldEnd,
 			newStart,
 			newEnd
-		}
+		},
+		removeWhenResolved: typeof removeWhenResolved === "boolean" ? removeWhenResolved : void 0
 	};
 }
 /** Narrow a wire payload to one keep/revert target. */
@@ -1647,6 +1824,18 @@ function targetOf(payload) {
 		id
 	};
 }
+/** Narrow a wire payload to one preview-image target. */
+function previewImageTargetOf(payload) {
+	const sessionId = sessionOf(payload);
+	if (sessionId === void 0) return void 0;
+	if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return void 0;
+	const path = payload.path;
+	if (typeof path !== "string" || path.length === 0) return void 0;
+	return {
+		sessionId,
+		path
+	};
+}
 /** Narrow a wire payload to one open target: the keep/revert pair plus the action. */
 function openTargetOf(payload) {
 	const target = targetOf(payload);

package/lib/types/client/ColorPicker.d.ts

@@ -0,0 +1,23 @@
+/** A compact HSV color picker (saturation/value square + hue bar + hex/RGB
+ *  input). Avoids the browser-native color dialog, which cannot be themed, so
+ *  it matches DSH. Pure helpers are exported for testing. */
+/** Parse `#rrggbb` / `#rgb` / `rrggbb` / `rgb(r,g,b)` into a normalised
+ *  `#rrggbb`, or `undefined` when the text is not a color. */
+export declare function parseColor(input: string): string | undefined;
+/** Convert a `#rrggbb` hex to HSV (h 0-360, s 0-1, v 0-1). */
+export declare function hexToHsv(hex: string): {
+    h: number;
+    s: number;
+    v: number;
+};
+/** Convert HSV (h 0-360, s 0-1, v 0-1) to a `#rrggbb` hex. */
+export declare function hsvToHex(h: number, s: number, v: number): string;
+/** A draggable HSV picker: saturation/value square + hue bar + a hex/RGB text
+ *  input. `onChange` reports a normalised `#rrggbb`; `onClose` fires after a
+ *  committed text value so the caller can close the popover. */
+export declare function ColorPicker({ value, onChange, onClose, ariaLabel, }: {
+    value: string;
+    onChange: (hex: string) => void;
+    onClose?: () => void;
+    ariaLabel: string;
+}): import("react").JSX.Element;

package/lib/types/client/PendingPanel.d.ts

@@ -7,6 +7,15 @@ import type { DiffApprovalKey } from './locales.ts';
 import { computeWholeFileDiff } from './whole-file-diff.ts';
 import type { IntraRun } from './whole-file-diff.ts';
 import { highlightLines } from './highlight.ts';
+/** Normalize a path for comparison: forward slashes, no trailing slash. */
+export declare function normalizeDiffPath(p: string): string;
+/** Whether a produced-file chip path and a pending file path refer to the same
+ *  file, tolerant of separator style (\\ vs /) and of a workspace-relative vs
+ *  absolute form. `chipPath` is typically the harness's workspace-relative
+ *  forward-slash path; `filePath` is the host's absolute native-separator path.
+ *  Matching is case-insensitive so a Windows drive/segment case difference does
+ *  not miss the file the user clicked. */
+export declare function diffPathsMatch(chipPath: string, filePath: string, workspacePath: string | undefined): boolean;
 /** The dsh shell's sidebar auto-collapse breakpoint (ui-layout columns.ts):
  * below it the sidebar auto-collapses, and the file list floats on the same
  * breakpoint so the two stay consistent. */
@@ -55,7 +64,7 @@ interface RowRange {
 /** Imperative surface the parent uses to drive block navigation from the
  *  shared toolbar/keyboard in split mode (its own `focus` is private here). */
 export interface SplitDiffHandle {
-    jump: (direction: -1 | 1, wrapGuard?: boolean) => void;
+    jump: (direction: -1 | 1, wrapGuard?: boolean, singleToast?: boolean) => void;
     openSearch: () => void;
     searchNext: (direction: -1 | 1) => boolean;
 }
@@ -84,5 +93,5 @@ export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
  */
 export declare function selectedPlainText(): string | undefined;
 /** Render the pending-edit review panel and its unified footer action. */
-export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, onPasteReference, onUndo, onRedo, onImportVcs, onAckRedoCleared, onAckJustResolved, collapseSidebar, t, }: PendingPanelProps): import("react").JSX.Element;
+export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, onPreviewImage, onPasteReference, onUndo, onRedo, onImportVcs, onKeepAll, onRevertAll, onAckRedoCleared, collapseSidebar, t, }: PendingPanelProps): import("react").JSX.Element;
 export {};

package/lib/types/client/locales.d.ts

@@ -32,10 +32,26 @@ export declare const zh: {
     'panel.splitModeDesc': string;
     'panel.navLeadRows': string;
     'panel.navLeadRowsDesc': string;
+    'panel.diffFontSize': string;
+    'panel.diffFontSizeDesc': string;
+    'panel.diffLineHeight': string;
+    'panel.diffLineHeightDesc': string;
+    'panel.mdPreview': string;
+    'panel.mdPreviewDesc': string;
+    'panel.mdMaxWidth': string;
+    'panel.mdMaxWidthDesc': string;
+    'panel.diffAddColor': string;
+    'panel.diffAddColorDesc': string;
+    'panel.diffDelColor': string;
+    'panel.diffDelColorDesc': string;
     'panel.quickSummon': string;
     'panel.quickSummonDesc': string;
     'panel.recordShortcut': string;
     'settings.keybindings': string;
+    'settings.keybindingsDesc': string;
+    'settings.diffView': string;
+    'settings.diffViewDesc': string;
+    'settings.diffPreview': string;
     'panel.keyDesc': string;
     'panel.key.jumpUp': string;
     'panel.key.jumpDown': string;
@@ -67,6 +83,13 @@ export declare const zh: {
     'action.hideFileList': string;
     'action.viewSplit': string;
     'action.viewUnified': string;
+    'action.viewPreview': string;
+    'action.viewSource': string;
+    'action.viewBefore': string;
+    'action.viewAfter': string;
+    'action.viewSingle': string;
+    'action.viewDouble': string;
+    'panel.mdPreviewFailed': string;
     'action.copyHint': string;
     'action.copied': string;
     'action.langAuto': string;
@@ -134,10 +157,26 @@ export declare const en: {
     'panel.splitModeDesc': string;
     'panel.navLeadRows': string;
     'panel.navLeadRowsDesc': string;
+    'panel.diffFontSize': string;
+    'panel.diffFontSizeDesc': string;
+    'panel.diffLineHeight': string;
+    'panel.diffLineHeightDesc': string;
+    'panel.mdPreview': string;
+    'panel.mdPreviewDesc': string;
+    'panel.mdMaxWidth': string;
+    'panel.mdMaxWidthDesc': string;
+    'panel.diffAddColor': string;
+    'panel.diffAddColorDesc': string;
+    'panel.diffDelColor': string;
+    'panel.diffDelColorDesc': string;
     'panel.quickSummon': string;
     'panel.quickSummonDesc': string;
     'panel.recordShortcut': string;
     'settings.keybindings': string;
+    'settings.keybindingsDesc': string;
+    'settings.diffView': string;
+    'settings.diffViewDesc': string;
+    'settings.diffPreview': string;
     'panel.keyDesc': string;
     'panel.key.jumpUp': string;
     'panel.key.jumpDown': string;
@@ -169,6 +208,13 @@ export declare const en: {
     'action.hideFileList': string;
     'action.viewSplit': string;
     'action.viewUnified': string;
+    'action.viewPreview': string;
+    'action.viewSource': string;
+    'action.viewBefore': string;
+    'action.viewAfter': string;
+    'action.viewSingle': string;
+    'action.viewDouble': string;
+    'panel.mdPreviewFailed': string;
     'action.copyHint': string;
     'action.copied': string;
     'action.langAuto': string;

package/lib/types/client/markdown-images.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Post-render local-image resolver for the Markdown preview. The preview body
+ * is rendered with `innerHTML` from the file's Markdown, so a local `<img
+ * src="details/foo.png">` stays a relative path that a browser cannot load on its
+ * own (the document's base URL is the DSH shell, not the file's folder). This
+ * pass rewrites those srcs to inline base64 data URIs through the host RPC,
+ * leaving absolute URLs and already-inlined data URIs untouched.
+ *
+ * Security: only the host reads the file, and the host confines reads to the
+ * session's workspace (see the `preview-image` endpoint). This module only
+ * computes the path to ask for — it never reads a file itself.
+ * @module dsh-diff-approval/client/markdown-images
+ */
+/**
+ * Resolve every local `<img src>` in a rendered Markdown preview to an inline
+ * data URI. Absolute URLs, fragments, and already-inlined data URIs are left as
+ * written; a reference the host cannot read keeps its original src.
+ * @param container - the preview body element (recently rendered).
+ * @param markdownPath - the Markdown file's backend path (for relative references).
+ * @param workspacePath - the session's workspace root, when known.
+ * @param resolveImage - the host call: maps a backend path to a data URI.
+ * @returns resolution once every image has been considered.
+ */
+export declare function resolvePreviewImages(container: HTMLElement, markdownPath: string, workspacePath: string | undefined, resolveImage: (path: string) => Promise<string | undefined>): Promise<void>;

package/lib/types/client/markdown-preview.d.ts

@@ -0,0 +1,20 @@
+/** Self-contained Markdown preview-diff renderer.
+ *
+ *  Renders the whole-file text diff at the Markdown level: the source diff is
+ *  computed first, then each added/removed/context run is rendered through
+ *  `marked` and presented single-column (merged, like the unified source diff)
+ *  or double-column (before | after). Every rendered block carries its run's
+ *  add/remove/context status so it can be tinted with the diff colors.
+ */
+/**
+ * Render the Markdown preview as sanitized HTML.
+ * @param oldText - the file's tracked baseline (rendered as "before").
+ * @param newText - the file's current content (rendered as "after").
+ * @param mode - 'single' merges add/remove/context (unified-like); 'double'
+ *   shows the before and after renderings aligned row by row, each change block
+ *   tinted (deleted on the before side, added on the after side). Comparable
+ *   edits get word-level highlights on the changed words.
+ * @returns sanitized HTML for the preview body. Local images keep their src so
+ *   a later pass can resolve them to data URIs (see the preview image resolver).
+ */
+export declare function renderMarkdownPreview(oldText: string, newText: string, mode: 'single' | 'double'): string;

package/lib/types/client/port.d.ts

@@ -5,7 +5,7 @@
  * @module dsh-diff-approval/client/port
  */
 import type { ClientConnectionRpc, SessionId } from '@deepseek-ai/dsh-client-connection/client';
-import type { DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, VcsImportValue } from '../types.ts';
+import type { DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalBulkValue, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, DiffApprovalPreviewImageValue, VcsImportValue } from '../types.ts';
 /** The channel the host half registers and this port calls. */
 export declare const DIFF_APPROVAL_CHANNEL = "/diff-approval";
 /** This package's business verbs over the review channel. */
@@ -17,9 +17,9 @@ export interface DiffApprovalPort {
     /** Revert one operation. */
     revert(sessionId: SessionId, id: string): Promise<DiffApprovalActionValue>;
     /** Keep one diff block (accept its change into the tracked baseline). */
-    blockKeep(sessionId: SessionId, id: string, block: DiffApprovalBlockRange): Promise<DiffApprovalActionValue>;
+    blockKeep(sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean): Promise<DiffApprovalActionValue>;
     /** Revert one diff block (restore its old lines in the file). */
-    blockRevert(sessionId: SessionId, id: string, block: DiffApprovalBlockRange): Promise<DiffApprovalActionValue>;
+    blockRevert(sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean): Promise<DiffApprovalActionValue>;
     /** Undo the session's last keep/revert (restore the before state). */
     undo(sessionId: SessionId): Promise<DiffApprovalActionValue>;
     /** Redo the session's last undone keep/revert (re-apply the after state). */
@@ -28,6 +28,12 @@ export interface DiffApprovalPort {
     importVcs(sessionId: SessionId, includeUntracked: boolean): Promise<VcsImportValue>;
     /** Open one file with its default application or reveal it in the folder. */
     open(sessionId: SessionId, id: string, action: DiffApprovalOpenAction): Promise<DiffApprovalOpenValue>;
+    /** Keep every pending entry of one session in a single host call (one batch). */
+    keepAll(sessionId: SessionId): Promise<DiffApprovalBulkValue>;
+    /** Revert every pending entry of one session in a single host call (one batch). */
+    revertAll(sessionId: SessionId): Promise<DiffApprovalBulkValue>;
+    /** Read one workspace image and inline it as a base64 data URI (for the Markdown preview). */
+    previewImage(sessionId: SessionId, path: string): Promise<DiffApprovalPreviewImageValue>;
 }
 /** Build the port over one generic RPC caller.
  * @param rpc - the connection's channel caller.

package/lib/types/client/settings.d.ts

@@ -3,6 +3,21 @@
 export declare const NAV_LEAD_ROWS_DEFAULT = 2;
 export declare const NAV_LEAD_ROWS_MIN = 0;
 export declare const NAV_LEAD_ROWS_MAX = 10;
+/** The code block's fixed row height used by the virtual window and jump math.
+ *  A hardcoded px base; the settings UI offers 10–36 (a low floor would clip the
+ *  code text, so the range is loose but never degenerate). */
+export declare const DIFF_LINE_HEIGHT_DEFAULT = 22;
+export declare const DIFF_LINE_HEIGHT_MIN = 10;
+export declare const DIFF_LINE_HEIGHT_MAX = 36;
+/** Font-size scale range: a percentage of the current value, stepped by 10. */
+export declare const DIFF_FONT_SCALE_DEFAULT = 100;
+export declare const DIFF_FONT_SCALE_MIN = 50;
+export declare const DIFF_FONT_SCALE_MAX = 200;
+/** Markdown-preview content max width (single column): a comfortable reading
+ *  width for mainstream 1080p+ displays. The double-column view is 2x this. */
+export declare const MD_MAX_WIDTH_DEFAULT = 800;
+export declare const MD_MAX_WIDTH_MIN = 480;
+export declare const MD_MAX_WIDTH_MAX = 1600;
 /**
  * Whether copying a reference should also paste it into the chat input and
  * focus it. Defaults to on; only an explicit `'0'` disables it.
@@ -40,6 +55,34 @@ export declare function setWrapEnabled(lang: string, value: boolean): void;
 export declare function tabWidth(): number;
 /** Persist the diff's tab width (in spaces). */
 export declare function setTabWidth(value: number): void;
+/**
+ * The diff code font size as a percentage of the current (theme) size. Defaults
+ * to 100 (the current look); the settings UI steps it by ±10.
+ * @returns the font-size scale, as a percentage (e.g. 100, 110, 90).
+ */
+export declare function diffFontScale(): number;
+/** Persist the diff's code font-size scale (a percentage). */
+export declare function setDiffFontScale(value: number): void;
+/**
+ * The diff code line height in px (the fixed row height the virtual window and
+ * jump math are keyed to). Defaults to 22 (the pre-customization value).
+ * @returns the line height in px.
+ */
+export declare function diffLineHeight(): number;
+/** Persist the diff's code line height (px). */
+export declare function setDiffLineHeight(value: number): void;
+/** The added-line base color the user chose, or `undefined` (theme color). */
+export declare function diffAddColor(): string | undefined;
+/** Persist the added-line base color (a hex like `#22c55e`). */
+export declare function setDiffAddColor(value: string): void;
+/** The removed-line base color the user chose, or `undefined` (theme color). */
+export declare function diffDelColor(): string | undefined;
+/** Persist the removed-line base color (a hex like `#ef4444`). */
+export declare function setDiffDelColor(value: string): void;
+/** The theme's added-line base color, for the settings swatch default. */
+export declare function currentDiffAddColor(): string;
+/** The theme's removed-line base color, for the settings swatch default. */
+export declare function currentDiffDelColor(): string;
 /**
  * Whether the whole-file diff view uses the two-column (side-by-side) layout.
  * Default off (single column): the unified diff. Only an explicit `'1'` enables
@@ -49,6 +92,24 @@ export declare function setTabWidth(value: number): void;
 export declare function splitMode(): boolean;
 /** Persist the split-view preference. */
 export declare function setSplitMode(value: boolean): void;
+/**
+ * Whether the rendered Markdown preview is shown by default (for Markdown files).
+ * Default off: the source diff is shown unless the panel toggle is used. Only an
+ * explicit `'1'` enables the preview default.
+ * @returns whether the Markdown preview default is enabled.
+ */
+export declare function mdPreviewEnabled(): boolean;
+/** Persist the Markdown-preview default preference. */
+export declare function setMdPreviewEnabled(value: boolean): void;
+/**
+ * The Markdown-preview content max width, in pixels (single column). Defaults to
+ * 800; the double-column view totals 2x this. An out-of-range or non-integer
+ * value falls back to the default.
+ * @returns the max width in pixels.
+ */
+export declare function mdMaxWidth(): number;
+/** Persist the Markdown-preview content max width. */
+export declare function setMdMaxWidth(value: number): void;
 /**
  * How many rows of lead the diff block jump leaves above the jumped-to block,
  * and how far the anchored navigation scans. Defaults to 2; an out-of-range or

package/lib/types/client/slots.d.ts

@@ -20,9 +20,6 @@ export interface PendingDiffSnapshot {
      * superseded the redo history; the panel surfaces it once (deferred if the
      * panel is closed) via a bottom-right notice. */
     redoCleared?: boolean;
-    /** Latched file id whose last block just resolved; the panel prompts once to
-     * remove-or-keep it, then acknowledges to clear the latch. */
-    justResolved?: string | undefined;
 }
 /** The injected face the panel component receives from the plugin body. */
 export interface PendingPanelFace {
@@ -37,11 +34,14 @@ export interface PendingPanelFace {
     /** Revert one operation (restore its prior content, or remove a created file). */
     onRevert: (sessionId: SessionId, id: string) => Promise<void>;
     /** Keep one diff block (accept its change into the tracked baseline). */
-    onBlockKeep: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
+    onBlockKeep: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean) => Promise<void>;
     /** Revert one diff block (restore its old lines in the file). */
-    onBlockRevert: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
+    onBlockRevert: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean) => Promise<void>;
     /** Open one file with its default application or reveal it in the folder. */
     onOpen: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
+    /** Inline one workspace image as a base64 data URI for the Markdown preview
+     * (empty when the host cannot read it). */
+    onPreviewImage: (sessionId: SessionId, path: string) => Promise<string | undefined>;
     /** Paste a copied reference into the session's chat input and focus it. */
     onPasteReference: (sessionId: SessionId, reference: string) => void;
     /** Undo the session's last keep/revert, then refresh the list; resolves to the affected entry id when it is still pending. */
@@ -50,10 +50,12 @@ export interface PendingPanelFace {
     onRedo: (sessionId: SessionId) => Promise<string | undefined>;
     /** Import the workspace's local VCS changes as pending entries (detection included). */
     onImportVcs: (sessionId: SessionId, includeUntracked: boolean) => Promise<VcsImportValue>;
+    /** Keep every pending entry of one session in a single host call (bulk). */
+    onKeepAll: (sessionId: SessionId) => Promise<void>;
+    /** Revert every pending entry of one session in a single host call (bulk). */
+    onRevertAll: (sessionId: SessionId) => Promise<void>;
     /** Acknowledge the redo-cleared notice so it is only surfaced once. */
     onAckRedoCleared: () => void;
-    /** Acknowledge the just-resolved prompt so it is only surfaced once. */
-    onAckJustResolved: () => void;
     /** Collapse the DSH sidebar (no-op when already collapsed) before the modal
      * opens or fullscreens, so an expanded sidebar can't overlap the modal. */
     collapseSidebar: () => void;