dsh-diff-approval 0.19.3 → 0.20.1

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;
@@ -76,7 +65,7 @@ export interface SplitDiffHandle {
 export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
     file: PendingFileDiff;
     model: RowModel;
-    runs: HighlightRuns | undefined;
+    runs: HighlightSides | undefined;
     langWrap: boolean;
     tabWidthSpaces: number;
     busy: boolean;
@@ -87,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
@@ -97,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, onRefreshVcs, 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

@@ -130,9 +130,32 @@ export declare const zh: {
     '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. */
@@ -269,4 +292,24 @@ export declare const en: {
     '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,7 +5,7 @@
  * @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, DiffApprovalRefreshValue, 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. */
@@ -28,6 +28,10 @@ export interface DiffApprovalPort {
     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/settings.d.ts

@@ -108,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, DiffApprovalRefreshValue, 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. */
@@ -54,6 +54,10 @@ export interface PendingPanelFace {
     /** 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/store.d.ts

@@ -7,7 +7,7 @@
  */
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
 import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
-import type { DiffApprovalBlockRange, DiffApprovalOpenAction, DiffApprovalRefreshValue, 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. */
@@ -31,6 +31,10 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     /** 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/pending.d.ts

@@ -74,6 +74,16 @@ export declare class PendingDiffStore {
      * @returns whether the store changed.
      */
     restore(entry: PendingEntry): boolean;
+    /**
+     * Admit one entry into the list without the change guard {@link fold} applies.
+     * A listed entry may carry no diff at all: a path the user added by hand has
+     * no local change until one appears, and a fully-resolved file has already
+     * folded its diff away. This is the guard-free put {@link restore} performs,
+     * named for its other caller.
+     * @param entry - the entry to insert or replace by path.
+     * @returns whether the store changed.
+     */
+    insert(entry: PendingEntry): boolean;
     /**
      * Merge persisted entries into the store, one per path after folding. A live
      * entry wins over a persisted one only when its time is newer (folders are

package/lib/types/types.d.ts

@@ -149,3 +149,54 @@ export interface DiffApprovalActionValue {
      * block (the entry stays listed with no pending diff). */
     resolved?: boolean | undefined;
 }
+/** One row of a browsed directory level. */
+export interface DiffApprovalBrowseEntry {
+    /** Base name inside the listed directory. */
+    name: string;
+    /** What the child is; `other` covers anything neither file nor directory. */
+    type: 'file' | 'directory' | 'other';
+    /** Absolute host path — the same value `add-path` takes, so the panel can show
+     *  (and add) exactly what a row names. */
+    path: string;
+    /** Byte size, present only for a regular file the backend reports. */
+    size?: number | undefined;
+}
+/** Value returned by the channel's list-path endpoint: one directory level. */
+export interface DiffApprovalBrowseValue {
+    /** The listed directory's absolute path. */
+    path: string;
+    /** Direct children: directories first, then files, each name-sorted. */
+    entries: DiffApprovalBrowseEntry[];
+    /** The response hit the entry cap, so children are missing from `entries`. */
+    truncated: boolean;
+}
+/** What one hand-added path did. */
+export type DiffApprovalAddOutcome = 
+/** At least one entry landed in the list (a directory can add many). */
+'added'
+/** Everything scanned was already listed; nothing changed. */
+ | 'duplicate'
+/** The path has no local VCS change and the caller did not ask to add those. */
+ | 'unchanged'
+/** A directory scan found nothing to add and nothing was listed already. */
+ | 'empty'
+/** The path does not exist (or is neither a file nor a directory). */
+ | 'missing'
+/** The path lies outside the session's workspace. */
+ | 'outside'
+/** The workspace is not inside a git/svn/p4 checkout. */
+ | 'no-vcs'
+/** The scan itself failed; `message` carries the reason. */
+ | 'failed';
+/** Value returned by the channel's add-path endpoint. */
+export interface DiffApprovalAddValue {
+    outcome: DiffApprovalAddOutcome;
+    /** How many entries the add put into the list. */
+    added: number;
+    /** How many scanned paths were already listed (left untouched). */
+    duplicates: number;
+    /** Whether the no-change walk hit its file cap, so some files were not added. */
+    truncated?: boolean | undefined;
+    /** Failure detail for `outcome: 'failed'`. */
+    message?: string | undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-diff-approval",
-  "version": "0.19.3",
+  "version": "0.20.1",
   "description": "DeepSeek Harness plugin: pending-edit review with whole-file diff and Keep/Revert",
   "packageManager": "pnpm@11.21.0",
   "author": "Wu Zhiwei",
@@ -67,18 +67,6 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1",
-    "@deepseek-ai/dsh-client-connection": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-client-locale": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-client-runtime": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-client-ui-primitives": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-client-ui-settings": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-client-ui-sidebar": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-client-ui-slots": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-fs": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-host-apiproxy": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-session": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.5",
-    "@deepseek-ai/dsh-workspace": ">=0.1.0-rc.5",
     "react": "^18.2.0"
   },
   "devDependencies": {