dsh-diff-approval 0.2.0

package/lib/index.js

@@ -0,0 +1,591 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { dshHomePath, expandHomePath } from "@deepseek-ai/dsh-home-paths";
+import { SessionId } from "@deepseek-ai/dsh-session";
+//#region lib/types/pending.js
+/**
+* In-memory pending-diff store: one entry per (session, path), holding the
+* file's full set of unhandled changes as one cumulative span. Every later
+* operation to a tracked path folds into its entry — `oldText` stays the
+* earliest basis, `newText` takes the latest content — even when the chain
+* breaks (an outside writer changed the file between operations): the list
+* still shows one element per file. Pure state and transitions; the plugin
+* body owns the `tools/result` observation, the RPC surface, and the
+* filesystem I/O.
+* @module dsh-diff-approval/src/pending
+*/
+/** Map key joining one session id and one entry id. */
+function entryKey(sessionId, id) {
+	return `${String(sessionId)}\u0000${id}`;
+}
+/** Map key joining one session id and one path, indexing the path's current entry. */
+function pathKey(sessionId, path) {
+	return `${String(sessionId)}\u0000${path}`;
+}
+/** Whether a merge changed nothing (a repeated operation is a no-op). */
+function sameEntry(left, right) {
+	return left.path === right.path && left.kind === right.kind && left.oldText === right.oldText && left.newText === right.newText && left.updatedAt === right.updatedAt;
+}
+/**
+* The pending-diff store. Keep/Revert decides one whole file at a time.
+*/
+var PendingDiffStore = class {
+	entries = /* @__PURE__ */ new Map();
+	pathIndex = /* @__PURE__ */ new Map();
+	/** Merge one operation into the store, keyed by (session, path). */
+	merge(entry) {
+		const key = pathKey(entry.sessionId, entry.path);
+		const currentId = this.pathIndex.get(key);
+		const current = currentId === void 0 ? void 0 : this.entries.get(entryKey(entry.sessionId, currentId));
+		const merged = current === void 0 ? { ...entry } : {
+			...current,
+			newText: entry.newText,
+			updatedAt: entry.updatedAt
+		};
+		if (current !== void 0 && sameEntry(current, merged)) return false;
+		this.entries.set(entryKey(entry.sessionId, merged.id), merged);
+		this.pathIndex.set(key, merged.id);
+		return true;
+	}
+	/**
+	* Fold one captured operation into its file's entry. A no-op (equal before
+	* and after) folds nothing.
+	* @param entry - the captured operation (id assigned by the caller).
+	* @returns whether the stored entry changed.
+	*/
+	fold(entry) {
+		if (entry.oldText === entry.newText) return false;
+		return this.merge(entry);
+	}
+	/**
+	* Merge persisted entries into the store, one per path after folding. An
+	* already-keyed live entry wins over a persisted one: the live entry is
+	* newer by construction (it was captured after the persisted state was
+	* written), so the path's whole persisted run is skipped.
+	* @param sessionId - the session the entries belong to.
+	* @param entries - persisted entries, oldest capture first, to fold in.
+	*/
+	hydrate(sessionId, entries) {
+		const livePaths = new Set(this.pathIndex.keys());
+		for (const entry of entries) {
+			const key = pathKey(sessionId, entry.path);
+			if (livePaths.has(key)) continue;
+			this.merge({
+				...entry,
+				sessionId
+			});
+		}
+	}
+	/**
+	* Copy the session's entries, oldest capture first.
+	* @param sessionId - the session whose entries to list.
+	* @returns detached entries in capture order.
+	*/
+	list(sessionId) {
+		const found = [];
+		for (const entry of this.entries.values()) if (entry.sessionId === sessionId) found.push(entry);
+		return found.sort((left, right) => left.updatedAt - right.updatedAt);
+	}
+	/**
+	* Read one entry without removing it.
+	* @param sessionId - the owning session.
+	* @param id - the entry id.
+	* @returns the entry, or `undefined` when the pair has none.
+	*/
+	get(sessionId, id) {
+		return this.entries.get(entryKey(sessionId, id));
+	}
+	/**
+	* Remove one entry.
+	* @param sessionId - the owning session.
+	* @param id - the entry id.
+	* @returns whether an entry was removed.
+	*/
+	remove(sessionId, id) {
+		if (!this.entries.delete(entryKey(sessionId, id))) return false;
+		for (const [key, indexedId] of this.pathIndex) if (indexedId === id) this.pathIndex.delete(key);
+		return true;
+	}
+	/** Total entry count across all sessions. */
+	get size() {
+		return this.entries.size;
+	}
+};
+//#endregion
+//#region lib/types/persist.js
+/**
+* Durable pending-entry persistence under the harness home. One JSON file per
+* workspace holds every session's entries, at
+* `<storageDir>/<workspaceId>.json`; the default root is
+* `<dshHome>/diff-approval/workspaces` and the plugin's `storageDir` config
+* relocates it. `save` rewrites the whole workspace file so sibling sessions
+* survive; a session with no entries leaves the file, and a workspace with no
+* sessions loses its file. Writes are serialized per file, staged as a
+* sibling temp file, and atomically renamed, so a crash leaves either the old
+* or the new file. Missing files read as empty; corrupt content and unknown
+* versions throw so the caller can fail loud instead of silently dropping
+* persisted data.
+* @module dsh-diff-approval/src/persist
+*/
+/** Default persistence root: this plugin's own directory under the harness home. */
+function defaultStorageDir() {
+	return dshHomePath("diff-approval", "workspaces");
+}
+/** On-disk envelope version; bumping it abandons older files (pre-release stance). */
+const FILE_VERSION = 2;
+/** Narrow one JSON value to a pending entry; malformed rows are skipped. */
+function pendingEntryOf(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const { id, sessionId, path, kind, oldText, newText, updatedAt } = value;
+	if (typeof id !== "string" || id.length === 0) return void 0;
+	if (typeof sessionId !== "string" || sessionId.length === 0) return void 0;
+	if (typeof path !== "string" || path.length === 0) return void 0;
+	if (kind !== "edit" && kind !== "create") return void 0;
+	if (typeof oldText !== "string" || typeof newText !== "string") return void 0;
+	if (typeof updatedAt !== "number") return void 0;
+	return {
+		id,
+		sessionId,
+		path,
+		kind,
+		oldText,
+		newText,
+		updatedAt
+	};
+}
+/**
+* Validate a parsed workspace file. Missing files yield `undefined` (empty);
+* anything else that is not a current-version workspace file throws so a
+* later save cannot silently overwrite unreadable persisted data.
+* @param file - the file path, for the error message.
+* @param value - the parsed JSON value.
+* @returns the validated file, or `undefined` when the file does not exist.
+*/
+function workspaceFileOf(file, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`pending persistence file '${file}' is not a workspace file`);
+	const { version, sessions } = value;
+	if (version !== FILE_VERSION) throw new Error(`pending persistence file '${file}' has unsupported version ${JSON.stringify(version)}`);
+	if (typeof sessions !== "object" || sessions === null || Array.isArray(sessions)) throw new Error(`pending persistence file '${file}' has no session map`);
+	return {
+		version,
+		sessions
+	};
+}
+/**
+* File-backed pending entries keyed by (workspace, session).
+*/
+var PendingPersistence = class {
+	root;
+	tails = /* @__PURE__ */ new Map();
+	/**
+	* @param root - directory holding one JSON file per workspace.
+	*/
+	constructor(root) {
+		this.root = root;
+	}
+	fileOf(workspaceId) {
+		return join(this.root, `${workspaceId}.json`);
+	}
+	/** Read one workspace file; a missing file reads as empty. */
+	async readWorkspace(file) {
+		let raw;
+		try {
+			raw = await readFile(file, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch (error) {
+			throw new Error(`pending persistence file '${file}' is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return workspaceFileOf(file, parsed);
+	}
+	/** Stage the envelope as a sibling temp file and atomically rename it into place. */
+	async writeWorkspace(file, envelope) {
+		await mkdir(this.root, { recursive: true });
+		const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+		await writeFile(tmp, JSON.stringify(envelope), "utf8");
+		try {
+			await rename(tmp, file);
+		} catch (error) {
+			await rm(tmp, { force: true }).catch(() => {});
+			throw error;
+		}
+	}
+	/**
+	* Load one session's entries from its workspace file, oldest capture first.
+	* @param workspaceId - the owning workspace's stable id.
+	* @param sessionId - the session whose entries to load.
+	* @returns the persisted entries; empty when none were saved.
+	*/
+	async load(workspaceId, sessionId) {
+		const envelope = await this.readWorkspace(this.fileOf(workspaceId));
+		if (envelope === void 0) return [];
+		const rows = envelope.sessions[String(sessionId)];
+		if (!Array.isArray(rows)) return [];
+		const entries = [];
+		for (const row of rows) {
+			const entry = pendingEntryOf(row);
+			if (entry !== void 0) entries.push(entry);
+		}
+		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
+	}
+	/**
+	* Replace one session's entries durably. Saves to one file are serialized;
+	* a previous save's failure does not block the next one.
+	* @param workspaceId - the owning workspace's stable id.
+	* @param sessionId - the session whose entries to replace.
+	* @param entries - the session's complete entry list, possibly empty.
+	* @returns resolution after the file is durable.
+	*/
+	save(workspaceId, sessionId, entries) {
+		const file = this.fileOf(workspaceId);
+		const task = async () => {
+			const envelope = await this.readWorkspace(file);
+			if (entries.length === 0) {
+				if (envelope === void 0) return;
+				delete envelope.sessions[String(sessionId)];
+				if (Object.keys(envelope.sessions).length === 0) {
+					await rm(file, { force: true });
+					return;
+				}
+				await this.writeWorkspace(file, envelope);
+				return;
+			}
+			const next = envelope ?? {
+				version: FILE_VERSION,
+				sessions: {}
+			};
+			next.sessions[String(sessionId)] = [...entries];
+			await this.writeWorkspace(file, next);
+		};
+		const run = (this.tails.get(file) ?? Promise.resolve()).then(task, task);
+		this.tails.set(file, run.catch(() => {}));
+		return run;
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/**
+* Pending-edit review, host half. Captures every successful `edit` and `write`
+* tool result (an unscoped `tools/result` listener receives per-session tool
+* executions because scoped emissions route through the shared root hook
+* table), folds each operation into its file's entry in the
+* {@link PendingDiffStore} (one entry per path), serves the `/diff-approval`
+* connection RPC channel (list/keep/revert), and applies a revert by writing
+* the entry's `oldText` back through `ctx.fs` (a created file's revert
+* removes it, and a tracked file that has since disappeared is restored by
+* its revert).
+*
+* Mount this row in any profile's `cordis.patch.yml`:
+*
+* ```yaml
+* - insert:
+*     - id: diff-approval
+*       name: 'dsh-diff-approval'
+*       # Optional: relocate durable pending state (defaults to
+*       # <dshHome>/diff-approval/workspaces).
+*       # config:
+*       #   storageDir: ~/.dsh/diff-approval/workspaces
+* ```
+*
+* Pending entries persist per (workspace, session) so an unhandled operation
+* survives a harness restart; the list endpoint re-reads the live file, so a
+* change or deletion made after the tracked operation is reported after
+* restart exactly as it is mid-session.
+*
+* @module dsh-diff-approval
+*/
+/** Stable Cordis plugin name. */
+const name = "diff-approval";
+/** Services required before the review surface activates. */
+const inject = [
+	"fs",
+	"connection",
+	"workspaceRegistry"
+];
+/** The connection RPC channel this plugin serves. */
+const DIFF_APPROVAL_CHANNEL = "/diff-approval";
+/**
+* Narrow a successful `edit` result value to an operation outcome. The edit
+* tool's output schema declares exactly `{ path, before, after }`; anything
+* else is another tool's value or malformed data, which this recorder skips.
+* @param value - the successful result's JSON value.
+* @returns the outcome, or `undefined` when the value is not an edit outcome.
+*/
+function editOutcomeOf(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const { path, before, after } = value;
+	if (typeof path !== "string" || path.length === 0) return void 0;
+	if (typeof before !== "string" || typeof after !== "string") return void 0;
+	return {
+		path,
+		kind: "edit",
+		oldText: before,
+		newText: after
+	};
+}
+/**
+* Narrow a successful `write` result value to an operation outcome. The write
+* tool's output schema declares `{ path, operation, before, after }`;
+* `operation: 'create'` becomes a `create` entry (revert removes the file),
+* `operation: 'update'` becomes an `edit` entry. An update whose `before` is
+* null carried no contextual basis, so it is skipped rather than tracked as
+* an un-revertable overwrite.
+* @param value - the successful result's JSON value.
+* @returns the outcome, or `undefined` when the value is not a trackable write.
+*/
+function writeOutcomeOf(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const { path, operation, before, after } = value;
+	if (typeof path !== "string" || path.length === 0) return void 0;
+	if (operation !== "create" && operation !== "update") return void 0;
+	if (typeof after !== "string") return void 0;
+	if (operation === "create") return {
+		path,
+		kind: "create",
+		oldText: "",
+		newText: after
+	};
+	if (typeof before !== "string") return void 0;
+	return {
+		path,
+		kind: "edit",
+		oldText: before,
+		newText: after
+	};
+}
+/** Human-readable message from an arbitrary thrown value. */
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* 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.
+* @returns the error branch.
+*/
+function rpcError(message) {
+	return {
+		ok: false,
+		error: {
+			code: "internal",
+			message,
+			details: {}
+		}
+	};
+}
+/**
+* Mount the pending-edit review surface.
+* @param ctx - Cordis context carrying the filesystem, connection, and workspace registry services.
+* @param config - optional plugin configuration (`storageDir` relocates durable state).
+*/
+function apply(ctx, config) {
+	const storageDir = config?.storageDir;
+	if (storageDir !== void 0 && (typeof storageDir !== "string" || storageDir.trim().length === 0)) throw new Error("diff-approval: storageDir must be a non-empty string");
+	const store = new PendingDiffStore();
+	const persistence = new PendingPersistence(resolve(expandHomePath(storageDir ?? defaultStorageDir())));
+	const loaded = /* @__PURE__ */ new Set();
+	const loading = /* @__PURE__ */ new Map();
+	/**
+	* Read one path's live state: present content, an unresolvable (missing)
+	* path, or a resolved-but-unreadable file.
+	* @param path - backend display path to probe through `ctx.fs`.
+	* @returns the live state.
+	*/
+	async function liveStateOf(path) {
+		let target;
+		try {
+			target = await ctx.fs.resolve(path, {});
+		} catch {
+			return {
+				present: false,
+				kind: "missing"
+			};
+		}
+		try {
+			return {
+				present: true,
+				content: await ctx.fs.readText(target, void 0)
+			};
+		} catch {
+			return {
+				present: false,
+				kind: "unreadable"
+			};
+		}
+	}
+	/**
+	* Attach the live file state to each listed entry. Reading runs once per
+	* path (the panel polls once a second and the review set stays small).
+	* @param entries - the store's entries for one session.
+	* @returns entries with `missing` and `diverged` set from the live file.
+	*/
+	async function listWithState(entries) {
+		const byPath = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const group = byPath.get(entry.path);
+			if (group === void 0) byPath.set(entry.path, [entry]);
+			else group.push(entry);
+		}
+		const listed = [];
+		for (const group of byPath.values()) {
+			const newest = group[group.length - 1];
+			if (newest === void 0) continue;
+			const live = await liveStateOf(newest.path);
+			const state = live.present ? {
+				missing: false,
+				diverged: live.content !== newest.newText
+			} : {
+				missing: live.kind === "missing",
+				diverged: live.kind === "unreadable"
+			};
+			for (const entry of group) listed.push({
+				...entry,
+				...state
+			});
+		}
+		return listed;
+	}
+	/**
+	* The workspace whose session account holds `sessionId`. Web sessions are
+	* attached to a workspace at creation, so an unowned session is the
+	* memory-only edge (its entries never persist).
+	* @param sessionId - the session to locate.
+	* @returns the owning workspace, or `undefined` when none accounts it.
+	*/
+	function workspaceOf(sessionId) {
+		for (const workspace of ctx.workspaceRegistry.list()) if (workspace.sessionIds.includes(sessionId)) return workspace;
+	}
+	/**
+	* Merge one session's persisted entries into the store, once per session.
+	* Concurrent callers share the in-flight load, and folds arriving while the
+	* load runs stay safe: `hydrate` never overwrites a live entry.
+	* @param sessionId - the session to hydrate.
+	* @returns resolution after the session's persisted state is merged (or skipped).
+	*/
+	function ensureLoaded(sessionId) {
+		const key = String(sessionId);
+		if (loaded.has(key)) return Promise.resolve();
+		const pending = loading.get(key);
+		if (pending !== void 0) return pending;
+		const task = (async () => {
+			const workspace = workspaceOf(sessionId);
+			if (workspace !== void 0) try {
+				store.hydrate(sessionId, await persistence.load(String(workspace.id), key));
+			} catch (error) {
+				ctx.logger.warn(`diff-approval: loading persisted state for session ${key} failed: ${errorMessage(error)}`);
+			}
+			loaded.add(key);
+			loading.delete(key);
+		})();
+		loading.set(key, task);
+		return task;
+	}
+	/**
+	* Mirror one session's entries to disk. A write fault logs a warning and
+	* leaves the in-memory view intact: the review flow must not break on a
+	* storage fault, and the next successful mutation rewrites the whole file.
+	* @param sessionId - the session whose complete entry list to save.
+	* @returns resolution after the write settles (successful or logged).
+	*/
+	async function persistSession(sessionId) {
+		await ensureLoaded(sessionId);
+		const workspace = workspaceOf(sessionId);
+		if (workspace === void 0) return;
+		try {
+			await persistence.save(String(workspace.id), String(sessionId), store.list(sessionId));
+		} catch (error) {
+			ctx.logger.warn(`diff-approval: persisting session ${String(sessionId)} failed: ${errorMessage(error)}`);
+		}
+	}
+	ctx.on("tools/result", (exec, result) => {
+		if (result.isError || exec.agent === void 0) return;
+		const outcome = exec.name === "edit" ? editOutcomeOf(result.value) : exec.name === "write" ? writeOutcomeOf(result.value) : void 0;
+		if (outcome === void 0 || outcome.oldText === outcome.newText) return;
+		const sessionId = exec.agent.id;
+		const entry = {
+			id: randomUUID(),
+			sessionId,
+			...outcome,
+			updatedAt: Date.now()
+		};
+		(async () => {
+			await ensureLoaded(sessionId);
+			if (store.fold(entry)) await persistSession(sessionId);
+		})();
+	});
+	const handle = async (endpoint, payload, signal) => {
+		switch (endpoint) {
+			case "list": {
+				const sessionId = sessionOf(payload);
+				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
+				await ensureLoaded(sessionId);
+				return {
+					ok: true,
+					value: { files: await listWithState(store.list(sessionId)) }
+				};
+			}
+			case "keep": {
+				const target = targetOf(payload);
+				if (target === void 0) return rpcError("sessionId and id must be non-empty strings");
+				await ensureLoaded(target.sessionId);
+				const removed = store.remove(target.sessionId, target.id);
+				if (removed) await persistSession(target.sessionId);
+				return {
+					ok: true,
+					value: { outcome: removed ? "kept" : "missing" }
+				};
+			}
+			case "revert": {
+				const target = targetOf(payload);
+				if (target === void 0) return rpcError("sessionId and id must be non-empty strings");
+				await ensureLoaded(target.sessionId);
+				const entry = store.get(target.sessionId, target.id);
+				if (entry === void 0) return {
+					ok: true,
+					value: { outcome: "missing" }
+				};
+				try {
+					const resolved = await ctx.fs.resolve(entry.path, { signal });
+					if (entry.kind === "create") await rm(ctx.fs.processPath(resolved), { force: true });
+					else await ctx.fs.writeText(resolved, entry.oldText, void 0, signal);
+				} catch (error) {
+					return rpcError(`revert failed: ${errorMessage(error)}`);
+				}
+				store.remove(target.sessionId, target.id);
+				await persistSession(target.sessionId);
+				return {
+					ok: true,
+					value: { outcome: "reverted" }
+				};
+			}
+			default: return rpcError(`unknown endpoint ${JSON.stringify(endpoint)}`);
+		}
+	};
+	ctx.effect(() => ctx.connection.rpc.handle(DIFF_APPROVAL_CHANNEL, handle, { authority: "trusted-host" }), "diff-approval: review channel");
+}
+/** Narrow a wire payload's `sessionId` field to a branded session id. */
+function sessionOf(payload) {
+	if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return void 0;
+	const value = payload.sessionId;
+	return typeof value === "string" && value.length > 0 ? SessionId(value) : void 0;
+}
+/** Narrow a wire payload to one keep/revert target. */
+function targetOf(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 id = payload.id;
+	if (typeof id !== "string" || id.length === 0) return void 0;
+	return {
+		sessionId,
+		id
+	};
+}
+//#endregion
+export { DIFF_APPROVAL_CHANNEL, PendingDiffStore, PendingPersistence, apply, defaultStorageDir, inject, name };

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

@@ -0,0 +1,7 @@
+/** Sidebar-foot pending-edit review action and the whole-file diff list it opens. */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { PendingPanelFace } from './slots.ts';
+/** Full panel props composed by the sidebar footer-action slot. */
+export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<PendingPanelFace> & PropsLocale<'diff-approval'>;
+/** Render the pending-edit review panel and its unified footer action. */
+export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, t, }: PendingPanelProps): import("react").JSX.Element;

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

@@ -0,0 +1,28 @@
+/**
+ * Basic syntax highlighting for the review viewer. A single synchronous
+ * fine-grained shiki core (JavaScript regex engine — no oniguruma WASM) with a
+ * fixed grammar set, all imported eagerly: the plugin serves one client bundle
+ * and must not code-split. Colors live in the harness theme's token sheets as
+ * `--shiki-*` custom properties via the CSS-variables theme, so token colors
+ * resolve against the web UI's existing vocabulary with no stylesheet of this
+ * package's own. An unknown or absent language falls back to plain text —
+ * never an error.
+ * @module dsh-diff-approval/client/highlight
+ */
+import type { CSSProperties } from 'react';
+/** One highlighted run of a line: literal text plus a color style. */
+export interface HighlightSpan {
+    text: string;
+    style: CSSProperties;
+}
+/**
+ * Tokenize `code` into per-line highlighted runs when `lang` names a
+ * registered grammar; `undefined` means the caller renders its plain fallback.
+ * Each run's color is a `--shiki-*` custom property, keeping token colors on
+ * the harness theme's sheets. The trailing newline shiki appends as a final
+ * empty line is dropped so the run count matches the caller's own line array.
+ * @param code - the source text.
+ * @param lang - the Shiki grammar id, or `undefined` for plain text.
+ * @returns one entry per source line (each an array of runs), or `undefined` when unhighlightable.
+ */
+export declare function highlightLines(code: string, lang: string | undefined): HighlightSpan[][] | undefined;

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

@@ -0,0 +1,13 @@
+/** Pending-edit review panel, browser half: footer action, pending list, and whole-file diff viewer. */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+export type { PendingPanelProps } from './PendingPanel.tsx';
+export type { PendingDiffSnapshot, PendingPanelFace } from './slots.ts';
+export type { DiffApprovalKey } from './locales.ts';
+export { DIFF_APPROVAL_CHANNEL } from './port.ts';
+/** Required services: locale, slots, the wire channel, and the current session. */
+export declare const inject: string[];
+/**
+ * Mount the pending-edit review panel.
+ * @param ctx - Client Cordis context carrying the wire and slot services.
+ */
+export declare function apply(ctx: ClientContext): void;

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

@@ -0,0 +1,12 @@
+/**
+ * File-extension → Shiki language-id mapping for the review viewer's basic
+ * syntax highlighting. Unknown extensions fall back to plain text, so the
+ * map stays an allow-list rather than a guess machine.
+ * @module dsh-diff-approval/client/lang
+ */
+/**
+ * Map a file path to a Shiki language id, or `undefined` for plain text.
+ * @param path - the file path, any separator style.
+ * @returns the language id, or `undefined` when unknown.
+ */
+export declare function langFromPath(path: string): string | undefined;