dsh-diff-approval 0.19.2 → 0.20.0

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

@@ -0,0 +1,43 @@
+/**
+ * The add-path dialog: pick one path in a lazily-loaded workspace tree — or type
+ * it outright — then press Add. Nothing is added by pointing at it: the path and
+ * the no-change box are prepared first, and the host judges them once the button
+ * is pressed.
+ *
+ * The path box is the single source of truth for the selection: a tree row is
+ * highlighted while its path is the box's text, and editing the text by hand
+ * simply leaves no row highlighted.
+ *
+ * The dialog is a modal inside the panel: it owns Escape while it is on screen
+ * (the panel's own chords stand down, see `pathPickerOpen`).
+ * @module dsh-diff-approval/client/PathPicker
+ */
+import type { ReactElement } from 'react';
+import type { DiffApprovalAddValue, DiffApprovalBrowseEntry } from '../types.ts';
+import type { Translator } from './locales.ts';
+/** Whether this panel's add-path dialog is on screen. The panel's global chords
+ *  consult this so the modal owns the keyboard while it is open. */
+export declare function pathPickerOpen(): boolean;
+/** Full props of the add-path dialog. */
+export interface PathPickerProps {
+    /** The session's workspace root (absolute), for the tree's top row. */
+    rootPath?: string | undefined;
+    /** List one workspace directory level (absolute path; undefined is the root). */
+    onBrowse: (path?: string) => Promise<{
+        path: string;
+        entries: DiffApprovalBrowseEntry[];
+        truncated: boolean;
+    }>;
+    /** Add the chosen path; resolves to what the host's scan did. */
+    onAdd: (path: string, includeUnchanged: boolean) => Promise<DiffApprovalAddValue>;
+    /** Transient banner for an outcome the dialog does not stay open for. */
+    onToast: (text: string) => void;
+    onClose: () => void;
+    t: Translator;
+}
+/**
+ * The add-path dialog.
+ * @param props - the workspace root, the host calls, and the close/toast sinks.
+ * @returns the modal (rendered only while open by its parent).
+ */
+export declare function PathPicker({ rootPath, onBrowse, onAdd, onToast, onClose, t }: PathPickerProps): ReactElement;

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

@@ -3,10 +3,11 @@ import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { DiffApprovalBlockRange, PendingFileDiff } from '../types.ts';
 import type { PendingPanelFace } from './slots.ts';
-import type { DiffApprovalKey } from './locales.ts';
+import type { Translator } from './locales.ts';
 import { computeWholeFileDiff } from './whole-file-diff.ts';
-import type { IntraRun } from './whole-file-diff.ts';
-import { highlightLines } from './highlight.ts';
+import type { ChangeBlock, IntraRun } from './whole-file-diff.ts';
+import type { HighlightSides } from './highlight.ts';
+import type { VisibleLines } from './windowed-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
@@ -23,8 +24,6 @@ export declare const SIDEBAR_AUTO_COLLAPSE_PX = 1024;
 export declare function wrapInto(text: string, widthPx: number, measure: (t: string) => number, tabPx: number): string[];
 /** Full panel props composed by the sidebar footer-action slot. */
 export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<PendingPanelFace> & PropsLocale<'diff-approval'>;
-/** Locale translator used by the panel and its rows. */
-type Translator = (key: DiffApprovalKey, params?: Record<string, unknown>) => string;
 /**
  * Open the DSH settings dialog and switch to this plugin's section. The
  * settings shell keeps its open state and the active section id as
@@ -43,16 +42,6 @@ interface RowModel {
     /** Intra-line runs keyed by row index, present only for annotated del/add rows. */
     intra: Map<number, IntraRun[]>;
 }
-/** One file's deferred syntax-highlight runs, one entry per side. */
-interface HighlightRuns {
-    oldRuns: ReturnType<typeof highlightLines>;
-    newRuns: ReturnType<typeof highlightLines>;
-}
-/** One contiguous run of changed rows, treated as a single modification. */
-interface ChangeBlock {
-    start: number;
-    end: number;
-}
 /** One selected line range in row indices, normalized low-to-high. */
 interface RowRange {
     start: number;
@@ -66,13 +55,17 @@ interface RowRange {
 export interface SplitDiffHandle {
     jump: (direction: -1 | 1, wrapGuard?: boolean, singleToast?: boolean) => void;
     openSearch: () => void;
+    toggleSearch: () => void;
+    closeSearch: () => boolean;
     searchNext: (direction: -1 | 1) => boolean;
+    toggleMatchCase: () => boolean;
+    toggleMatchWholeWord: () => boolean;
 }
 /** The two-column (side-by-side) whole-file diff view. */
 export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
     file: PendingFileDiff;
     model: RowModel;
-    runs: HighlightRuns | undefined;
+    runs: HighlightSides | undefined;
     langWrap: boolean;
     tabWidthSpaces: number;
     busy: boolean;
@@ -83,6 +76,9 @@ export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
     onBlockRevert: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
     /** Notify the parent to toast a block-wrap boundary / single-block (Ctrl+Up/Down). */
     onWrapToast: (text: string) => void;
+    /** Report which source lines this view is showing, so the parent's windowed
+     *  highlighter follows this view's own scroller (it has its own virtual window). */
+    onVisibleLines: (visible: VisibleLines) => void;
 } & import("react").RefAttributes<SplitDiffHandle>>;
 /**
  * Reconstruct the plain text of the current selection so auto-wrap's visual
@@ -93,5 +89,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, onPreviewImage, onPasteReference, onUndo, onRedo, onImportVcs, onKeepAll, onRevertAll, onAckRedoCleared, 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, onRefreshVcs, onBrowse, onAddPath, onKeepAll, onRevertAll, onAckRedoCleared, collapseSidebar, t, }: PendingPanelProps): import("react").JSX.Element;
 export {};

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

@@ -10,11 +10,42 @@
  * @module dsh-diff-approval/client/highlight
  */
 import type { CSSProperties } from 'react';
+import type { HighlighterCore } from 'shiki/core';
 /** One highlighted run of a line: literal text plus a color style. */
 export interface HighlightSpan {
     text: string;
     style: CSSProperties;
 }
+/** One file's highlight runs, one entry per side and line (index = line - 1). A
+ *  hole means that line has not been highlighted — the viewer renders it plain,
+ *  which is the honest state of a windowed highlighter: only what has been looked
+ *  at is tokenized. */
+export interface HighlightSides {
+    oldRuns: HighlightSpan[][];
+    newRuns: HighlightSpan[][];
+}
+/** A saved grammar state: resuming from one continues tokenization *exactly*
+ *  where it stopped, instead of assuming the window's first line starts the file.
+ *  Opaque to callers — only `highlightWindow` produces and consumes it, and
+ *  `undefined` means "no saved state" (the file's first line is top-level). */
+export type HighlightState = Parameters<HighlighterCore['codeToTokens']>[1]['grammarState'];
+/** One highlighted window: the requested lines' runs and the grammar state after
+ *  the last of them, for an exact continuation by the next window. */
+export interface HighlightWindow {
+    runs: HighlightSpan[][];
+    state: HighlightState;
+}
+/** Options for {@link highlightWindow}. */
+export interface HighlightWindowOptions {
+    /** Lines of preceding context to run the grammar over without returning them,
+     *  so a window starting inside a multi-line construct (a block comment, a
+     *  template literal, a fenced code block) still colours correctly. Ignored when
+     *  `state` is given: that one is exact. */
+    context?: number;
+    /** An exact state saved at this window's first line (a previous window's
+     *  `state`). */
+    state?: HighlightState;
+}
 /**
  * Primary grammar ids offered in the viewer's language selector, in picker
  * order (alphabetical). Kept explicit instead of deriving from `LANGS`: some
@@ -28,13 +59,25 @@ export declare const HIGHLIGHT_LANGS: string[];
 /** Conventional display name for a grammar id, falling back to the id itself. */
 export declare function languageDisplayName(id: string): string;
 /**
- * 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.
+ * Tokenize the lines `[from, to)` 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 array.
+ *
+ * This is the viewer's only entry point, and it is deliberately windowed: the
+ * code view renders a virtual window of rows, so highlighting a whole file to
+ * show one screenful is almost all waste (measured on a 3818-line file: ~945 ms
+ * for both sides whole-file against ~8 ms for one window). A window is continued
+ * *exactly* from a previous one's `state`, or approximately from `context` lines
+ * when no state is known yet — which is what lets a jump straight to the middle
+ * of a file colour correctly without tokenizing anything above it.
+ * @param lines - the side's lines, indexed from 0 as the caller's line numbers are.
  * @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.
+ * @param from - the first line index to highlight (inclusive, clamped).
+ * @param to - one past the last line index to highlight (clamped).
+ * @param options - the grammar state to resume from and/or context lines for the grammar.
+ * @returns the window's runs and its end state, or `undefined` when the language
+ *   is unknown, the range is empty, or the window's own text is too large.
  */
-export declare function highlightLines(code: string, lang: string | undefined): HighlightSpan[][] | undefined;
+export declare function highlightWindow(lines: readonly string[], lang: string | undefined, from: number, to: number, options?: HighlightWindowOptions): HighlightWindow | undefined;

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

@@ -10,3 +10,11 @@
  * @returns the language id, or `undefined` when unknown.
  */
 export declare function langFromPath(path: string): string | undefined;
+/**
+ * The lowercase extension of a file path, without the dot — the key a manual
+ * language choice is remembered under. A name with no dot has no suffix, so a
+ * per-suffix preference never leaks onto every extension-less file at once.
+ * @param path - the file path, any separator style.
+ * @returns the suffix, or `undefined` when the name carries none.
+ */
+export declare function suffixOfPath(path: string): string | undefined;

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

@@ -59,6 +59,8 @@ export declare const zh: {
     'panel.key.openSearch': string;
     'panel.key.searchNext': string;
     'panel.key.searchPrev': string;
+    'panel.key.matchCase': string;
+    'panel.key.matchWholeWord': string;
     'panel.key.undo': string;
     'panel.key.redo': string;
     'panel.key.cycleNext': string;
@@ -116,9 +118,44 @@ export declare const zh: {
     'status.missing': string;
     'panel.resolvedAsk': string;
     'panel.keepInList': string;
+    'panel.fileKeptAsk': string;
+    'panel.fileRevertedAsk': string;
+    'panel.confirmFileRemove': string;
+    'panel.confirmFileRemoveDesc': string;
+    'action.refreshVcs': string;
+    'action.matchCase': string;
+    'action.matchWholeWord': string;
+    'panel.refreshDone': string;
+    'panel.refreshUnchanged': string;
+    'panel.refreshNone': string;
+    'panel.refreshUntrackedHint': string;
+    'panel.refreshFailed': string;
+    'action.addPath': string;
+    'panel.addTitle': string;
+    'panel.addPathPlaceholder': string;
+    'panel.addPathGo': string;
+    'panel.addHint': string;
+    'panel.addIncludeUnchanged': string;
+    'panel.addRoot': string;
+    'panel.addTruncated': string;
+    'panel.addDone': string;
+    'panel.addDoneTruncated': string;
+    'panel.addDuplicate': string;
+    'panel.addUnchanged': string;
+    'panel.addEmpty': string;
+    'panel.addNoEntries': string;
+    'panel.addMissing': string;
+    'panel.addOutside': string;
+    'panel.addFailed': string;
+    'action.cancel': string;
+    'action.collapseRow': string;
+    'action.expandRow': string;
 };
 /** Translation keys owned by the pending-edit review namespace. */
 export type DiffApprovalKey = keyof typeof zh;
+/** Locale translator for this plugin's namespace: the panel's and the settings
+ *  section's `t`, typed against the dictionary keys. */
+export type Translator = (key: DiffApprovalKey, params?: Record<string, unknown>) => string;
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
         /** Pending-edit review UI copy. */
@@ -184,6 +221,8 @@ export declare const en: {
     'panel.key.openSearch': string;
     'panel.key.searchNext': string;
     'panel.key.searchPrev': string;
+    'panel.key.matchCase': string;
+    'panel.key.matchWholeWord': string;
     'panel.key.undo': string;
     'panel.key.redo': string;
     'panel.key.cycleNext': string;
@@ -241,4 +280,36 @@ export declare const en: {
     'status.missing': string;
     'panel.resolvedAsk': string;
     'panel.keepInList': string;
+    'panel.fileKeptAsk': string;
+    'panel.fileRevertedAsk': string;
+    'panel.confirmFileRemove': string;
+    'panel.confirmFileRemoveDesc': string;
+    'action.refreshVcs': string;
+    'action.matchCase': string;
+    'action.matchWholeWord': string;
+    'panel.refreshDone': string;
+    'panel.refreshUnchanged': string;
+    'panel.refreshNone': string;
+    'panel.refreshUntrackedHint': string;
+    'panel.refreshFailed': string;
+    'action.addPath': string;
+    'panel.addTitle': string;
+    'panel.addPathPlaceholder': string;
+    'panel.addPathGo': string;
+    'panel.addHint': string;
+    'panel.addIncludeUnchanged': string;
+    'panel.addRoot': string;
+    'panel.addTruncated': string;
+    'panel.addDone': string;
+    'panel.addDoneTruncated': string;
+    'panel.addDuplicate': string;
+    'panel.addUnchanged': string;
+    'panel.addEmpty': string;
+    'panel.addNoEntries': string;
+    'panel.addMissing': string;
+    'panel.addOutside': string;
+    'panel.addFailed': string;
+    'action.cancel': string;
+    'action.collapseRow': string;
+    'action.expandRow': string;
 };

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

@@ -5,17 +5,17 @@
  * @module dsh-diff-approval/client/port
  */
 import type { ClientConnectionRpc, SessionId } from '@deepseek-ai/dsh-client-connection/client';
-import type { DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalBulkValue, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, DiffApprovalPreviewImageValue, VcsImportValue } from '../types.ts';
+import type { DiffApprovalActionValue, DiffApprovalAddValue, DiffApprovalBlockRange, DiffApprovalBrowseValue, DiffApprovalBulkValue, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, DiffApprovalPreviewImageValue, DiffApprovalRefreshValue, 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. */
 export interface DiffApprovalPort {
     /** Read one session's pending entries (plus its workspace root), oldest capture first. */
     list(sessionId: SessionId): Promise<DiffApprovalListValue>;
-    /** Keep one operation. */
-    keep(sessionId: SessionId, id: string): Promise<DiffApprovalActionValue>;
-    /** Revert one operation. */
-    revert(sessionId: SessionId, id: string): Promise<DiffApprovalActionValue>;
+    /** Keep one operation. `keepListed` leaves the resolved entry in the list. */
+    keep(sessionId: SessionId, id: string, keepListed?: boolean): Promise<DiffApprovalActionValue>;
+    /** Revert one operation. `keepListed` leaves the resolved entry in the list. */
+    revert(sessionId: SessionId, id: string, keepListed?: boolean): Promise<DiffApprovalActionValue>;
     /** Keep one diff block (accept its change into the tracked baseline). */
     blockKeep(sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean): Promise<DiffApprovalActionValue>;
     /** Revert one diff block (restore its old lines in the file). */
@@ -26,6 +26,12 @@ export interface DiffApprovalPort {
     redo(sessionId: SessionId): Promise<DiffApprovalActionValue>;
     /** Import the workspace's local VCS changes as pending entries. */
     importVcs(sessionId: SessionId, includeUntracked: boolean): Promise<VcsImportValue>;
+    /** Replace one entry's diff with the file's current local VCS change. */
+    refreshVcs(sessionId: SessionId, id: string, includeUntracked: boolean): Promise<DiffApprovalRefreshValue>;
+    /** List one workspace directory level (workspace-relative; `''` is the root). */
+    browse(sessionId: SessionId, path?: string): Promise<DiffApprovalBrowseValue>;
+    /** Add one named path (a file, or a directory's whole subtree) to the list. */
+    addPath(sessionId: SessionId, path: string, includeUnchanged: boolean): Promise<DiffApprovalAddValue>;
     /** 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). */

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

@@ -0,0 +1,23 @@
+/**
+ * The in-file search matcher, shared by the unified diff and the split view so
+ * both highlight and count the same occurrences.
+ * @module dsh-diff-approval/client/search
+ */
+/** Which occurrences an in-file search accepts. */
+export interface SearchOptions {
+    /** Match the query's letter case exactly. */
+    caseSensitive: boolean;
+    /** Accept only whole words (no identifier character touching either end). */
+    wholeWord: boolean;
+}
+/** The plain search: case-insensitive, substring. */
+export declare const DEFAULT_SEARCH_OPTIONS: SearchOptions;
+/**
+ * Character ranges of every occurrence of `query` in `text` that the options
+ * accept. Case-insensitive and substring-based unless narrowed.
+ * @param text - the line to search.
+ * @param query - the search text; empty matches nothing.
+ * @param options - case and whole-word narrowing.
+ * @returns `[start, end)` ranges in ascending order.
+ */
+export declare function matchRangesOf(text: string, query: string, options?: SearchOptions): [number, number][];

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

@@ -36,6 +36,31 @@ export declare function setPasteOnCopyEnabled(value: boolean): void;
 export declare function includeUntrackedEnabled(): boolean;
 /** Persist the import-untracked preference. */
 export declare function setIncludeUntrackedEnabled(value: boolean): void;
+/**
+ * Whether a whole-file keep/revert asks before dropping the resolved file from
+ * the list. Defaults to on; only an explicit `'0'` disables it, which then
+ * removes the file straight away.
+ * @returns whether the remove prompt is enabled.
+ */
+export declare function confirmFileRemoveEnabled(): boolean;
+/** Persist the whole-file remove-prompt preference. */
+export declare function setConfirmFileRemoveEnabled(value: boolean): void;
+/**
+ * Whether the in-file search matches letter case exactly. Defaults to off, so a
+ * plain query keeps matching either case; only an explicit `'1'` turns it on.
+ * @returns whether the search is case-sensitive.
+ */
+export declare function searchCaseSensitive(): boolean;
+/** Persist the search case-sensitivity preference. */
+export declare function setSearchCaseSensitive(value: boolean): void;
+/**
+ * Whether the in-file search only matches whole words. Defaults to off; only an
+ * explicit `'1'` enables it.
+ * @returns whether the search matches whole words only.
+ */
+export declare function searchWholeWord(): boolean;
+/** Persist the search whole-word preference. */
+export declare function setSearchWholeWord(value: boolean): void;
 /**
  * Whether lines wrap (auto-wrap) in the diff for one highlight language.
  * Defaults to off; only an explicit `'1'` enables it. Stored per language, so
@@ -83,6 +108,22 @@ export declare function setDiffDelColor(value: string): void;
 export declare function currentDiffAddColor(): string;
 /** The theme's removed-line base color, for the settings swatch default. */
 export declare function currentDiffDelColor(): string;
+/**
+ * The highlight language chosen by hand for one file suffix, remembered so the
+ * choice sticks for every file with that suffix. Not a Settings row: it is a
+ * per-suffix consequence of using the language picker, so it lives here as
+ * storage only.
+ * @param suffix - the lowercase extension without the dot (see `suffixOfPath`).
+ * @returns the remembered language id, or undefined for "auto".
+ */
+export declare function languageForSuffix(suffix: string): string | undefined;
+/**
+ * Remember (or clear) the language chosen for one suffix. A `null` language
+ * forgets the suffix, which is what picking "auto" means.
+ * @param suffix - the lowercase extension without the dot.
+ * @param language - the language id, or null to forget the suffix.
+ */
+export declare function setLanguageForSuffix(suffix: string, language: string | null): void;
 /**
  * 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

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

@@ -1,7 +1,7 @@
 /** The panel's injected business face and its observable snapshot. */
 import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
-import type { DiffApprovalBlockRange, DiffApprovalOpenAction, PendingFileDiff, VcsImportValue } from '../types.ts';
+import type { DiffApprovalAddValue, DiffApprovalBlockRange, DiffApprovalBrowseValue, DiffApprovalOpenAction, DiffApprovalRefreshValue, PendingFileDiff, VcsImportValue } from '../types.ts';
 /** What the panel reads and drives: the pending list plus in-flight entries. */
 export interface PendingDiffSnapshot {
     /** Whether a list read has completed at least once. */
@@ -29,10 +29,11 @@ export interface PendingPanelFace {
     };
     /** Read the pending list for the current session into the snapshot. */
     onRefresh: (sessionId: SessionId | undefined) => void;
-    /** Keep one operation (remove it from the pending list). */
-    onKeep: (sessionId: SessionId, id: string) => Promise<void>;
-    /** Revert one operation (restore its prior content, or remove a created file). */
-    onRevert: (sessionId: SessionId, id: string) => Promise<void>;
+    /** Keep one operation. `keepListed` leaves the resolved entry in the list. */
+    onKeep: (sessionId: SessionId, id: string, keepListed?: boolean) => Promise<void>;
+    /** Revert one operation (restore its prior content, or remove a created file).
+     *  `keepListed` leaves the resolved entry in the list. */
+    onRevert: (sessionId: SessionId, id: string, keepListed?: boolean) => Promise<void>;
     /** Keep one diff block (accept its change into the tracked baseline). */
     onBlockKeep: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean) => Promise<void>;
     /** Revert one diff block (restore its old lines in the file). */
@@ -50,6 +51,13 @@ 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>;
+    /** Replace one entry's diff with the file's current local VCS change, then
+     *  refresh the list; resolves to what the scan found. */
+    onRefreshVcs: (sessionId: SessionId, id: string, includeUntracked: boolean) => Promise<DiffApprovalRefreshValue>;
+    /** List one workspace directory level for the add-path dialog. */
+    onBrowse: (sessionId: SessionId, path?: string) => Promise<DiffApprovalBrowseValue>;
+    /** Add one named path (a file, or a directory's whole subtree) to the list. */
+    onAddPath: (sessionId: SessionId, path: string, includeUnchanged: boolean) => Promise<DiffApprovalAddValue>;
     /** 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). */

package/lib/types/client/split-diff.d.ts

@@ -8,6 +8,7 @@
  * @module dsh-diff-approval/client/split-diff
  */
 import type { WholeFileDiffRow } from './whole-file-diff.ts';
+import type { SearchOptions } from './search.ts';
 /** One side of a split pair: text plus its 1-based line number (absent on a pure add). */
 export interface SplitSide {
     /** The side's source line content, without the terminating newline. */
@@ -43,12 +44,13 @@ export interface SplitDiff {
  */
 export declare function computeSideBySideDiff(rows: readonly WholeFileDiffRow[], alignBySimilarity?: boolean): SplitDiff;
 /**
- * Pair indices whose left or right text contains the query (case-insensitive).
- * A pair counts once however many times the query appears, so split search
- * highlights the whole pair on both columns and a single "current" pair is
- * stepped through — not each individual left/right occurrence.
+ * Pair indices whose left or right text matches the query. A pair counts once
+ * however many times the query appears, so split search highlights the whole pair
+ * on both columns and a single "current" pair is stepped through — not each
+ * individual left/right occurrence.
  * @param pairs - the split pairs.
  * @param query - the query text; an empty query matches nothing.
+ * @param options - case and whole-word narrowing.
  * @returns matching pair indices, in file order.
  */
-export declare function searchPairs(pairs: readonly SplitPair[], query: string): number[];
+export declare function searchPairs(pairs: readonly SplitPair[], query: string, options?: SearchOptions): number[];

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

@@ -7,17 +7,17 @@
  */
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
 import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
-import type { DiffApprovalBlockRange, DiffApprovalOpenAction, VcsImportValue } from '../types.ts';
+import type { DiffApprovalAddValue, DiffApprovalBlockRange, DiffApprovalBrowseValue, DiffApprovalOpenAction, DiffApprovalRefreshValue, VcsImportValue } from '../types.ts';
 import type { PendingDiffSnapshot } from './slots.ts';
 import type { DiffApprovalPort } from './port.ts';
 /** The observable the panel reads and the plugin body drives. */
 export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     /** Re-read one session's pending list (an absent session empties the view). */
     refresh: (sessionId: SessionId | undefined) => Promise<void>;
-    /** Keep one operation. */
-    keep: (sessionId: SessionId, id: string) => Promise<void>;
-    /** Revert one operation. */
-    revert: (sessionId: SessionId, id: string) => Promise<void>;
+    /** Keep one operation. `keepListed` leaves the resolved entry in the list. */
+    keep: (sessionId: SessionId, id: string, keepListed?: boolean) => Promise<void>;
+    /** Revert one operation. `keepListed` leaves the resolved entry in the list. */
+    revert: (sessionId: SessionId, id: string, keepListed?: boolean) => Promise<void>;
     /** Keep one diff block, then refresh so the entry's diff reflects the accept. */
     blockKeep: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean) => Promise<void>;
     /** Revert one diff block, then refresh so the entry's diff reflects the undo. */
@@ -28,6 +28,13 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     redo: (sessionId: SessionId) => Promise<string | undefined>;
     /** Import the workspace's local VCS changes as pending entries, then refresh. */
     importVcs: (sessionId: SessionId, includeUntracked: boolean) => Promise<VcsImportValue>;
+    /** Replace one entry's diff with the file's current local VCS change, then
+     *  refresh; resolves to what the scan found. */
+    refreshVcs: (sessionId: SessionId, id: string, includeUntracked: boolean) => Promise<DiffApprovalRefreshValue>;
+    /** List one workspace directory level for the add-path dialog. */
+    browse: (sessionId: SessionId, path?: string) => Promise<DiffApprovalBrowseValue>;
+    /** Add one named path to the list, then refresh; resolves to what the scan did. */
+    addPath: (sessionId: SessionId, path: string, includeUnchanged: boolean) => Promise<DiffApprovalAddValue>;
     /** Open one file with its default application or reveal it in the folder. */
     open: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
     /** Keep every pending entry of one session in a single host call, then refresh. */

package/lib/types/client/whole-file-diff.d.ts

@@ -5,6 +5,7 @@
  * derivation; the panel owns rendering. The `diff` package is browser-safe.
  * @module dsh-diff-approval/client/whole-file-diff
  */
+import type { DiffApprovalBlockRange } from '../types.ts';
 /** One rendered body line of the whole-file view. */
 export interface WholeFileDiffRow {
     /** `context` lines are unchanged, `del`/`add` mark the removed/added sides. */
@@ -25,6 +26,26 @@ export interface WholeFileDiff {
     /** Number of added lines. */
     added: number;
 }
+/** One contiguous run of changed rows, treated as a single modification. */
+export interface ChangeBlock {
+    start: number;
+    end: number;
+}
+/** Split a row list into maximal runs of non-context rows. */
+export declare function changeBlocksOf(diff: WholeFileDiff): ChangeBlock[];
+/**
+ * One diff block's old/new line ranges, 1-based inclusive, for block-level
+ * keep/revert. A side with no lines (a pure addition or deletion) is empty; its
+ * start is that side's insertion point — the line after the surrounding context
+ * — so the host can insert there.
+ *
+ * Shared by the source view and the Markdown preview: both derive blocks from
+ * the same rows, so a preview element and a source row name the same target.
+ * @param rows - the whole-file diff rows.
+ * @param block - the block's row range.
+ * @returns the old and new line ranges.
+ */
+export declare function blockRangesOf(rows: readonly WholeFileDiffRow[], block: ChangeBlock): DiffApprovalBlockRange;
 /**
  * Compute the whole-file view between two contents. The context budget is the
  * side lengths, so every hunk covers the file and unchanged lines survive as

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

@@ -0,0 +1,66 @@
+/**
+ * Windowed syntax highlighting for the diff viewer.
+ *
+ * The code view renders a virtual window of rows, so the viewer only ever needs
+ * the colors of the lines near the viewport. Highlighting a whole file to show
+ * one screenful is almost all waste — measured on a 3818-line file, the two
+ * sides whole-file cost ~945 ms of main-thread time against ~8 ms for one window
+ * — so this hook keeps a per-side store of highlighted lines and fills it:
+ *
+ * 1. **The window first.** Whenever the visible line range changes, the lines
+ *    that are missing are highlighted (with a margin either side, debounced, so a
+ *    fast scroll computes the window it lands on instead of every window it
+ *    passes). A window with no state yet gets `context` lines above it so a
+ *    construct that started earlier still colours correctly.
+ * 2. **Already-highlighted lines are kept.** Scrolling back, or nudging the
+ *    window by a few rows, finds the lines present and does no work at all.
+ * 3. **An idle backfill** walks the file top-down in chunks when the pane reports
+ *    a real viewport, recording the exact grammar state at each chunk boundary.
+ *    Windows inside a backfilled region then resume exactly (no context guess),
+ *    and a random scroll position is coloured before the user gets there.
+ *
+ * Lines that have never been highlighted are holes in the returned arrays: the
+ * viewer renders them plain, which is the honest state of the work done so far.
+ * @module dsh-diff-approval/client/windowed-highlight
+ */
+import type { HighlightSides } from './highlight.ts';
+/** One visible window, in source lines (1-based, inclusive). */
+export interface LineRange {
+    from: number;
+    to: number;
+}
+/** The source lines one view is showing, plus whether that view measured a real
+ *  viewport. Reported by whichever view is mounted (the single column computes its
+ *  own window; the split view reports its own, which is the only one that matches
+ *  its scroll container). */
+export interface VisibleLines {
+    oldRange: LineRange | undefined;
+    newRange: LineRange | undefined;
+    live: boolean;
+}
+/** What the hook needs to know about the file and the pane. */
+export interface WindowedHighlightInput {
+    /** Identity of the content and language: a change resets everything. */
+    key: unknown;
+    /** The old side's lines (index 0 = line 1). */
+    oldLines: readonly string[];
+    /** The new side's lines (index 0 = line 1). */
+    newLines: readonly string[];
+    /** The Shiki grammar id, or undefined for plain text. */
+    lang: string | undefined;
+    /** The visible source lines of the old side, if any are on screen. */
+    oldRange: LineRange | undefined;
+    /** The visible source lines of the new side, if any are on screen. */
+    newRange: LineRange | undefined;
+    /** Whether the pane reports a real viewport. The idle backfill only runs with
+     *  one: without a viewport (a test DOM, a pane that has not measured yet) there
+     *  is no "idle" to spend and nothing to prefetch for. */
+    live: boolean;
+}
+/**
+ * Keep syntax highlighting for the pane's visible window, plus (with a live
+ * viewport) an idle top-down backfill of the rest.
+ * @param input - the file's lines, language, and the visible line ranges.
+ * @returns the runs per side, indexed by line - 1, with holes for unhighlighted lines.
+ */
+export declare function useWindowedHighlight(input: WindowedHighlightInput): HighlightSides;

package/lib/types/index.d.ts

@@ -35,7 +35,7 @@
  */
 import { Context } from '@deepseek-ai/cordis';
 import type { DiffApprovalOpenAction } from './types.ts';
-export type { DiffApprovalActionOutcome, DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalBlockTarget, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, PendingEntry, PendingEntryKind, PendingFileDiff, } from './types.ts';
+export type { DiffApprovalActionOutcome, DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalBlockTarget, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, DiffApprovalRefreshOutcome, DiffApprovalRefreshValue, PendingEntry, PendingEntryKind, PendingFileDiff, } from './types.ts';
 export { PendingDiffStore } from './pending.ts';
 export { PendingPersistence, defaultStorageDir } from './persist.ts';
 export { defaultOpenPath } from './open.ts';