dsh-diff-approval 0.20.1 → 0.22.0

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

@@ -23,7 +23,18 @@ export declare function diffPathsMatch(chipPath: string, filePath: string, works
 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'>;
+export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<PendingPanelFace> & PropsLocale<'diff-approval'> & PendingPanelDockProps;
+/** How the panel is hosted when it is not the footer's floating overlay: the
+ *  right sidebar's tab renders it docked, filling the tab and portaling its
+ *  content into `dockHost` (the element the tab body owns). */
+export interface PendingPanelDockProps {
+    /** Docked in the sidebar tab: no badge, no overlay positioning, no composer
+     *  offset, and no header of its own — the tab's chip carries the title, the
+     *  mode switch, and the kit's close button. */
+    docked?: boolean;
+    /** The element the docked panel portals its content into. */
+    dockHost?: HTMLElement;
+}
 /**
  * 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
@@ -34,6 +45,26 @@ export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFa
  * @param sectionLabel - the nav label of this plugin's settings section.
  */
 export declare function openSettingsSection(sectionLabel: string): void;
+/**
+ * How much of the window the app itself occupies on each side of the conversation
+ * — how far the floating panel has to start from an edge to leave that part
+ * visible.
+ *
+ * The centre column's own box is the direct answer: the header above it, an
+ * expanded sidebar, a collapsed rail, and a right panel hanging over the centre
+ * all sit outside it. The frame's grid tracks fill in the rest — they name the
+ * sidebar columns even before a conversation is mounted, and a right sidebar shown
+ * without a track of its own draws over the centre, so its own panel is measured
+ * instead. Relying on the frame's *resizers* alone was a bug: a collapsed sidebar
+ * renders no resizer, so a collapsed rail read as "nothing on that side".
+ * @returns each side's occupied size, 0 when that side shows nothing.
+ */
+export declare function frameInsets(): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
 /** One file's synchronous view: diff rows and change blocks. */
 interface RowModel {
     diff: ReturnType<typeof computeWholeFileDiff>;
@@ -89,5 +120,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, onBrowse, onAddPath, 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, docked, dockHost, onOpenDock, closeDock, useDock, }: PendingPanelProps): import("react").JSX.Element;
 export {};

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

@@ -0,0 +1,38 @@
+/**
+ * A crash inside the panel must not take the review away for the rest of the page.
+ *
+ * The slot renderer wraps every seat in its own boundary, but a crash there
+ * *abdicates* the entry: the footer row, the header button and the docked tab
+ * disappear for the life of the page, with nothing on screen to say why and no way
+ * back but a reload. This boundary keeps a failure inside our own tree instead —
+ * the entry stays registered, it says what happened, and one press retries the
+ * render — so a broken panel can never present as "the panel is gone" or as a
+ * blank surface with no explanation.
+ *
+ * @module dsh-diff-approval/client/boundary
+ */
+import { Component } from 'react';
+import type { ErrorInfo, ReactNode } from 'react';
+import type { Translator } from './locales.ts';
+/** Props of the boundary and of the face it shows in place of its children. */
+export interface PanelBoundaryProps {
+    /** The panel mount to keep contained. */
+    children?: ReactNode;
+    /** The panel's translator, for the failure note's copy. */
+    t: Translator;
+}
+/** State: whether a child has thrown since the last retry. */
+interface PanelBoundaryState {
+    failed: boolean;
+}
+/**
+ * Keep one panel mount's crash inside its own slot entry, with a visible note and
+ * a retry that re-renders it.
+ */
+export declare class PanelBoundary extends Component<PanelBoundaryProps, PanelBoundaryState> {
+    state: PanelBoundaryState;
+    static getDerivedStateFromError(): PanelBoundaryState;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

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

@@ -0,0 +1,49 @@
+/**
+ * How a keybinding is spelled in a tooltip.
+ *
+ * Every hint reads the binding at render time rather than baking in a default, so
+ * a rebind in Settings shows up everywhere the chord is advertised. That is also
+ * why the strings live here: the panel's header, its diff toolbars, and the
+ * coverage popover all advertise chords, and they must spell them the same way.
+ *
+ * @module dsh-diff-approval/client/chords
+ */
+import type { Translator } from './locales.ts';
+/**
+ * One stored chord as a hint renders it: modifiers as written, arrow keys as
+ * glyphs (`Ctrl+ArrowUp` → `Ctrl+↑`).
+ * @param chord - the stored chord.
+ * @returns the hint text; `''` for an unbound action.
+ */
+export declare function chordHint(chord: string): string;
+/**
+ * One action's chord as a hint.
+ * @param action - the keybinding action id (see `DEFAULT_KEYBINDINGS`).
+ * @returns the hint text; `''` when the action has no chord.
+ */
+export declare function chordLabel(action: string): string;
+/**
+ * A tooltip label with the action's configured chord appended. The hint states
+ * the binding the user actually has — including one rebound in Settings, or none
+ * at all, which simply adds nothing.
+ * @param label - the translated action label.
+ * @param action - the keybinding action id (see `DEFAULT_KEYBINDINGS`).
+ * @returns the label, with ` (chord)` appended when one is configured.
+ */
+export declare function withChord(label: string, action: string): string;
+/**
+ * How the panel's close button names its two ways out: Escape, and the
+ * quick-summon chord when the user still has one bound. Unbinding the chord
+ * leaves Escape as the only answer, so the hint then says just that.
+ * @param t - the panel's translator.
+ * @returns the tooltip label.
+ */
+export declare function closeHint(t: Translator): string;
+/**
+ * How an entry button names what it opens: the pending-changes panel, plus the
+ * chord that does the same. With the chord unbound the plain label is the whole
+ * hint — never an empty parenthetical.
+ * @param t - the panel's translator.
+ * @returns the tooltip label.
+ */
+export declare function summonHint(t: Translator): string;

package/lib/types/client/coverage-control.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The floating panel's coverage control: one header button, and a popover of
+ * three glyph buttons — cover the left sidebar, the composer below, the right
+ * sidebar. All three on is what the panel used to call "fullscreen".
+ *
+ * Each glyph is the same rounded rectangle with one band highlighted, drawn to
+ * the product's icon conventions (16px grid, ~1.4px ink, `currentColor`): the
+ * band is filled while that side is covered and hollow while it is not, so the
+ * shape says *which* edge and the fill says whether it is on. The popover is a
+ * row rather than the kit's vertical menu because these are three independent
+ * switches, not a list of choices.
+ *
+ * @module dsh-diff-approval/client/coverage-control
+ */
+import type { ReactElement, ReactNode } from 'react';
+import type { DiffApprovalCover } from './settings.ts';
+import type { Translator } from './locales.ts';
+/** One coverage switch: its key, and the keybinding action whose chord the
+ *  button advertises. */
+type CoverKey = keyof DiffApprovalCover;
+export interface CoverageControlProps {
+    t: Translator;
+    cover: DiffApprovalCover;
+    onToggle: (key: CoverKey) => void;
+}
+/** How long the chord's on-screen echo stays up, matching its CSS animation. */
+export declare const COVER_NOTICE_MS = 1250;
+/**
+ * The chord's echo: the same row of glyphs the popover shows, centred on screen,
+ * shown the moment a coverage chord flips a switch and fading out after a second.
+ * It is a report, not a control — nothing in it is pressable — so a keyboard flip
+ * is as visible as a click, without a pointer target appearing under the mouse.
+ * @param props - copy, the coverage after the flip, and which edge just changed.
+ * @returns the notice.
+ */
+export declare function CoverageNotice({ t, cover, changed }: {
+    t: Translator;
+    cover: DiffApprovalCover;
+    changed: CoverKey;
+}): ReactNode;
+/**
+ * The trigger and its popover. Marked with `data-diff-approval-cover`, and each
+ * switch with `data-diff-approval-cover-<key>`, so the two halves are addressable
+ * apart.
+ * @param props - copy, the current coverage, and what a switch does.
+ * @returns the header control.
+ */
+export declare function CoverageControl({ t, cover, onToggle }: CoverageControlProps): ReactElement;
+export {};

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

@@ -0,0 +1,198 @@
+/**
+ * The app's right sidebar (the docking surface) as a host for the review panel.
+ *
+ * The sidebar is an extensible tab system: a tab type registers its static face
+ * with the `sidebarRightTabs` service, its body in the keyed `sidebar.right.pane.tab`
+ * seat under the same `id`, and is opened by `kind` through `sidebarRight`. The
+ * harness documents this as the path a *package outside the product* takes (its
+ * own document preview ships that way), so nothing here imports the sidebar's
+ * package as a runtime value: the shapes below are the structural minimum, which
+ * is exactly what lets this plugin keep loading on releases that have no right
+ * sidebar at all — the type is simply never registered there.
+ *
+ * @module dsh-diff-approval/client/dock
+ */
+import type { ReactNode } from 'react';
+import type { HostObservable, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { PendingDiffSnapshot } from './slots.ts';
+/** The tab type's `kind`: what `openTab` names. */
+export declare const DIFF_DOCK_KIND = "diff-approval";
+/** The registration's `id`: the key its body and title register under. The
+ *  registry wants a name unique across implementations, and the package name is
+ *  the natural value. */
+export declare const DIFF_DOCK_ID = "dsh-diff-approval";
+/** Window event a docked panel dispatches to move the panel back to the overlay.
+ *  The docked tab and the footer entry are separate mounts, so the ask travels as
+ *  an event — the same bridge the produced-file buttons use. */
+export declare const SHOW_PANEL_EVENT = "diff-approval:show-panel";
+/** Ask the panel to toggle: what the header entry's button does. It runs the same
+ *  action as the footer badge, so the two entries can never disagree about what a
+ *  press means — including for a docked panel, whose tab the chip still closes. */
+export declare const TOGGLE_PANEL_EVENT = "diff-approval:toggle-panel";
+/** The floating panel's own visibility, published on every change so a second
+ *  entry can light up while the panel is open (`detail.open`). */
+export declare const PANEL_STATE_EVENT = "diff-approval:panel-state";
+/** Name a file for the panel to show, from a mount that is not the panel itself
+ *  (the produced-file chip): every mounted panel instance switches to it and lands
+ *  on its first change — the ask is "show me this diff", not "put me back where I
+ *  was". The file is also recorded as the last one, so an instance that only
+ *  appears afterwards (the docked tab) opens the same file the same way. */
+export declare const OPEN_PANEL_FILE_EVENT = "diff-approval:panel-file";
+/** Payload of {@link OPEN_PANEL_FILE_EVENT}. */
+export interface PanelFileDetail {
+    /** The pending entry to show. */
+    fileId: string;
+}
+/** Payload of {@link PANEL_STATE_EVENT}. */
+export interface PanelStateDetail {
+    /** Whether the floating panel is showing right now. */
+    open: boolean;
+}
+/** What the footer entry needs to know about the dock. */
+export interface DockSnapshot {
+    /** Whether this build has a right sidebar to dock into at all. */
+    readonly available: boolean;
+    /** Whether our tab is currently showing: reported by the docked tab body
+     *  itself, because the sidebar's controller exposes no observable. */
+    readonly open: boolean;
+    /** Why it is unavailable, when it is: the lookup result, for the user to report. */
+    readonly reason: string | undefined;
+}
+/** The dock's face to the panel: an observable for the entry, the reveal the
+ *  entry calls, the close the chip publishes, and the visibility the docked body
+ *  reports. All exist from apply time — see {@link createDockState}. */
+export interface DockFace {
+    readonly hooks: {
+        readonly dock: HostObservable<DockSnapshot>;
+    };
+    /** Expand the sidebar and focus our tab, opening it when it is missing; a
+     *  no-op while no sidebar is attached. Throws when the sidebar is mounted but
+     *  cannot act (no seat bound yet), which the panel reports. */
+    readonly open: () => void;
+    /** The docked tab body's own visibility, so the footer entry can light up. */
+    readonly setShowing: (showing: boolean) => void;
+    /** The chip's own close, so a chord can close the docked tab from anywhere —
+     *  the tab is the only thing that knows how to close itself, and it is not
+     *  mounted where the footer entry lives. `undefined` once the tab is gone. */
+    readonly setClose: (close: (() => void) | undefined) => void;
+    /** Close our docked tab, when one exists. */
+    readonly close: () => void;
+}
+/** The dock's live state, independent of when the sidebar's services attach. */
+export interface DockState {
+    readonly face: DockFace;
+    /** Swap the live sidebar in (undefined when its services go away), with the
+     *  reason to report while there is none; returns the detach function. */
+    attach(sidebar: unknown, reason?: string): () => void;
+}
+/** Structural view of the tab-type registry (see the module note). */
+export interface TabRegistryFace {
+    register(definition: {
+        id: string;
+        kind: string;
+        title: (address: string) => string;
+        guide?: readonly {
+            order: number;
+            title: () => string;
+            description?: () => string;
+        }[];
+    }): () => void;
+}
+/** The tab seat's own tab hook, injected by the sidebar framework: the record
+ *  being drawn (with the seat's verdict on whether it is on screen) and the
+ *  actions that act on it. */
+type TabInfoHook = () => {
+    readonly tab: {
+        readonly actions: {
+            close(): void;
+        };
+        /** Whether this record is actually on screen (expanded column, active tab). */
+        readonly visible: boolean;
+    };
+};
+export interface DiffDockBodyProps extends PropsLocale<'diff-approval'> {
+    /** The seat's own tab hook (the sidebar framework injects it). */
+    readonly useTabInfo?: TabInfoHook;
+    /** This plugin's pending store hook, for the chip's count. */
+    readonly usePending?: (select: (snapshot: PendingDiffSnapshot) => unknown) => unknown;
+    /** Whether the panel renders as the docked body (set by the tab seat's face). */
+    readonly docked?: boolean;
+    /** Report this body's visibility to the dock state (see {@link DockFace}). */
+    readonly onDockShowing?: ((showing: boolean) => void) | undefined;
+    /** Publish this tab's own close, so a chord can close the docked panel. */
+    readonly onDockClose?: ((close: (() => void) | undefined) => void) | undefined;
+    [key: string]: unknown;
+}
+/** One live dock adapter: the face, and the teardown that unsubscribes. */
+export interface DiffDock {
+    readonly face: DockFace;
+    dispose(): void;
+}
+/** The cordis pieces this adapter uses, structurally: optional service lookup and
+ *  a scoped effect. Both are what the plugin sandbox always forwards — its
+ *  whitelist covers `effect`/`on`/timers but NOT cordis's dynamic `inject`, and it
+ *  gates *direct* service access on the plugin's declared inject list (which must
+ *  not name the sidebar: the panel has to keep working where there is none). `get`
+ *  is the one lookup it never gates, so discovery goes through it. */
+export interface DockHostContext {
+    get(name: string): unknown;
+    effect(callback: () => unknown, label: string): void;
+}
+/**
+ * The dock's live state, created at apply time rather than when the sidebar's
+ * services appear. The footer entry is seated once, so a face captured before the
+ * sidebar attaches would freeze on "no dock" and the panel would never offer the
+ * switch — the state below is therefore always present, and `attach` swaps the
+ * live sidebar underneath it while `open` resolves the current one per call.
+ * @returns the state; `attach` reports availability and the tab's own visibility.
+ */
+export declare function createDockState(): DockState;
+/**
+ * The tab body: the review panel, docked. The panel's content is one portaled
+ * block, so instead of restructuring it this hands it a host element of the
+ * sidebar's own making to portal into — the tab body owns the element it fills.
+ * @param props - the seat's runtime props, this plugin's face, and `useTabInfo`.
+ * @returns the host element and, once it exists, the docked panel inside it.
+ */
+/** Keeps a failure inside the tab from taking the app's tree down with it, and
+ *  from leaving the pane blank: {@link PanelBoundary} says what happened and can
+ *  re-render the panel without a reload. */
+export declare function DiffDockBody(props: DiffDockBodyProps): ReactNode;
+/**
+ * The tab chip: the mode switch, then the panel's title with the pending count —
+ * read live from the store so the chip tracks the list without re-registering the
+ * tab. The glyph leads because that is this seat's convention (the document tab
+ * puts its file-type icon there), and because the chip's tail is masked for the
+ * kit's own close button.
+ *
+ * A docked panel draws no header of its own, so this chip is where the panel is
+ * named *and* where it is told to leave: the mode switch offers the two overlay
+ * states, and its menu footer keeps this plugin's Settings one click away, which
+ * the docked panel has no gear for.
+ * @param props - the same face the body gets; the count and the switch are drawn.
+ * @returns the chip content.
+ */
+export declare function DiffDockTitle(props: DiffDockBodyProps): ReactNode;
+/**
+ * Find the sidebar's services and, once they are there, attach the panel to them:
+ * register the tab type (with a guide entry, so the panel is discoverable from the
+ * sidebar's own guide page) and hand the live sidebar to `attach`. Where they are
+ * never provided — an older app, or a composition without the right sidebar —
+ * nothing is registered and nothing attaches, which is what makes the whole
+ * feature optional rather than required.
+ *
+ * Discovery is a timed optional lookup rather than cordis's dynamic `inject`,
+ * because the plugin sandbox forwards `effect`/`on`/timers but not `inject`, and
+ * the sidebar may attach after this plugin does. Timers are the window's own (the
+ * sandbox's ctx timer verbs want a `timer` declaration, and a host that withholds
+ * the verb must not take the panel down with it).
+ * @param ctx - the client context (structurally, see {@link DockHostContext}).
+ * @param copy - the tab's copy, read per call so a language change needs no
+ *   re-registration.
+ * @param attach - takes the live sidebar; returns its detach.
+ */
+export declare function attachDiffDock(ctx: DockHostContext, copy: {
+    title: () => string;
+    guideDescription: () => string;
+}, attach: (sidebar: unknown, reason?: string) => () => void): void;
+export {};

package/lib/types/client/header-entry.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The pending-changes entry in the Session header.
+ *
+ * The sidebar footer's badge is only where the sidebar is: with the sidebar
+ * collapsed to its rail, or hidden on a narrow window, the review has no entry.
+ * The Session header's right-aligned utilities hold the app's own per-session
+ * controls — "open in app" and the more-actions button the session-log export
+ * lives behind — and are visible whatever the sidebar does. This seats the same
+ * action there: one compact button carrying the pending count.
+ *
+ * The header entry is a *second mount* of one action, not a second panel: the
+ * click travels to the mount that owns the open state ({@link TOGGLE_PANEL_EVENT})
+ * and the visibility comes back ({@link PANEL_STATE_EVENT}), because the two sit
+ * in different slot trees and neither owns the other. That is also why a press is
+ * exactly the footer badge's press: a docked panel's tab is revealed, and still
+ * closed by the chip on its own tab rather than from here.
+ *
+ * @module dsh-diff-approval/client/header-entry
+ */
+import type { ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
+import type { PendingDiffSnapshot } from './slots.ts';
+import type { DockSnapshot } from './dock.tsx';
+/** What the header entry reads from this plugin's own face: the two observables.
+ *  Everything else it needs (the button's own click) goes through the window
+ *  events, so the entry never holds a copy of the panel's state. */
+export interface HeaderEntryFace {
+    hooks: {
+        /** Live pending-diff snapshot: the count on the button. */
+        pending: HostObservable<PendingDiffSnapshot>;
+        /** The dock's state, absent in a build without a right sidebar. */
+        dock?: HostObservable<DockSnapshot>;
+    };
+}
+/** The framework session-list seats this entry reads, as far as it reads them.
+ *  Both are optional so the entry still renders where a host provides neither. */
+export interface HeaderEntrySeat {
+    /** The selected session and its rows; the entry is inert without one. */
+    useSessions?: ((select: (state: HeaderEntrySessions) => boolean) => boolean) | undefined;
+}
+/** The slice of the session list this entry reads. */
+export interface HeaderEntrySessions {
+    /** The session the app is showing. */
+    current?: SessionId | undefined;
+    /** Known sessions by id, for the blank-session check. */
+    byId: Record<string, {
+        blank?: boolean;
+    } | undefined>;
+}
+/** Full props of the header entry: the injected face's hooks bound as
+ *  `usePending`/`useDock`, the framework seats, and the locale `t`. */
+export type DiffApprovalHeaderEntryProps = InjectFace<HeaderEntryFace> & HeaderEntrySeat & PropsLocale<'diff-approval'>;
+/**
+ * Render the Session header's pending-changes button.
+ * @param props - the bound hooks, the session seat, and the translator.
+ * @returns the icon button, with the pending count while there is one.
+ */
+export declare function DiffApprovalHeaderEntry({ usePending, useSessions, useDock, t }: DiffApprovalHeaderEntryProps): ReactNode;

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

@@ -4,6 +4,9 @@ export declare const NS = "diff-approval";
 export declare const zh: {
     'panel.title': string;
     'panel.empty': string;
+    'panel.dockGuide': string;
+    'panel.dockUnavailable': string;
+    'panel.dockFailed': string;
     'panel.loading': string;
     'panel.readFailed': string;
     'panel.group.current': string;
@@ -53,6 +56,8 @@ export declare const zh: {
     'settings.diffViewDesc': string;
     'settings.diffPreview': string;
     'panel.keyDesc': string;
+    'panel.shortcutNone': string;
+    'panel.shortcutReset': string;
     'panel.key.jumpUp': string;
     'panel.key.jumpDown': string;
     'panel.key.copyRef': string;
@@ -65,6 +70,10 @@ export declare const zh: {
     'panel.key.redo': string;
     'panel.key.cycleNext': string;
     'panel.key.cyclePrev': string;
+    'panel.key.coverLeft': string;
+    'panel.key.coverComposer': string;
+    'panel.key.coverRight': string;
+    'panel.key.coverTop': string;
     'settings.tabLabel': string;
     'row.create': string;
     'row.failed': string;
@@ -83,6 +92,8 @@ export declare const zh: {
     'action.nextDiff': string;
     'action.showFileList': string;
     'action.hideFileList': string;
+    'action.fileListFloatOn': string;
+    'action.fileListFloatOff': string;
     'action.viewSplit': string;
     'action.viewUnified': string;
     'action.viewPreview': string;
@@ -110,9 +121,31 @@ export declare const zh: {
     'panel.importFailed': string;
     'action.search': string;
     'action.settings': string;
-    'action.expand': string;
-    'action.exitFullscreen': string;
+    'action.presentation': string;
+    'action.presentationCurrent': string;
+    'action.cover': string;
+    'cover.left': string;
+    'cover.right': string;
+    'cover.composer': string;
+    'cover.top': string;
+    'cover.leftDesc': string;
+    'cover.topDesc': string;
+    'cover.rightDesc': string;
+    'cover.composerDesc': string;
+    'settings.cover': string;
+    'settings.coverDesc': string;
+    'cover.on': string;
+    'cover.off': string;
+    'cover.notice': string;
+    'action.presentationFloat': string;
+    'action.presentationDock': string;
+    'action.presentationDocked': string;
     'action.close': string;
+    'action.closeHint': string;
+    'action.closeHintEsc': string;
+    'action.summonHint': string;
+    'action.retry': string;
+    'panel.crashed': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;
@@ -166,6 +199,9 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
 export declare const en: {
     'panel.title': string;
     'panel.empty': string;
+    'panel.dockGuide': string;
+    'panel.dockUnavailable': string;
+    'panel.dockFailed': string;
     'panel.loading': string;
     'panel.readFailed': string;
     'panel.group.current': string;
@@ -215,6 +251,8 @@ export declare const en: {
     'settings.diffViewDesc': string;
     'settings.diffPreview': string;
     'panel.keyDesc': string;
+    'panel.shortcutNone': string;
+    'panel.shortcutReset': string;
     'panel.key.jumpUp': string;
     'panel.key.jumpDown': string;
     'panel.key.copyRef': string;
@@ -227,6 +265,10 @@ export declare const en: {
     'panel.key.redo': string;
     'panel.key.cycleNext': string;
     'panel.key.cyclePrev': string;
+    'panel.key.coverLeft': string;
+    'panel.key.coverComposer': string;
+    'panel.key.coverRight': string;
+    'panel.key.coverTop': string;
     'settings.tabLabel': string;
     'row.create': string;
     'row.failed': string;
@@ -245,6 +287,8 @@ export declare const en: {
     'action.nextDiff': string;
     'action.showFileList': string;
     'action.hideFileList': string;
+    'action.fileListFloatOn': string;
+    'action.fileListFloatOff': string;
     'action.viewSplit': string;
     'action.viewUnified': string;
     'action.viewPreview': string;
@@ -272,9 +316,31 @@ export declare const en: {
     'panel.importFailed': string;
     'action.search': string;
     'action.settings': string;
-    'action.expand': string;
-    'action.exitFullscreen': string;
+    'action.presentation': string;
+    'action.presentationCurrent': string;
+    'action.cover': string;
+    'cover.left': string;
+    'cover.right': string;
+    'cover.composer': string;
+    'cover.top': string;
+    'cover.leftDesc': string;
+    'cover.topDesc': string;
+    'cover.rightDesc': string;
+    'cover.composerDesc': string;
+    'settings.cover': string;
+    'settings.coverDesc': string;
+    'cover.on': string;
+    'cover.off': string;
+    'cover.notice': string;
+    'action.presentationFloat': string;
+    'action.presentationDock': string;
+    'action.presentationDocked': string;
     'action.close': string;
+    'action.closeHint': string;
+    'action.closeHintEsc': string;
+    'action.summonHint': string;
+    'action.retry': string;
+    'panel.crashed': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;

package/lib/types/client/panel-memory.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Where the review panel was left, for this page's lifetime.
+ *
+ * Closing the panel is not "done reviewing": reopening it should put the reader
+ * back on the file they were in, at the offset they were at. That is a fact about
+ * this visit rather than a stored preference, so it lives in module state — which
+ * also gives the two mounts that show the panel (the floating overlay and the
+ * docked tab) one shared memory, so switching presentation does not lose the
+ * place, and a reload starts clean.
+ *
+ * Keyed by session: two sessions have their own pending lists, and one session's
+ * panel must not resume another's file.
+ *
+ * @module dsh-diff-approval/client/panel-memory
+ */
+/**
+ * Remember that a session's panel was left showing one file, and where in it.
+ * @param sessionId - the session the panel was reviewing; nothing is recorded
+ *   without one.
+ * @param view - the pending entry that was open, and the code view's scrollTop.
+ *   An absent offset *forgets* any remembered place for that file, which is what
+ *   a caller that is about to open it at its first change wants: a mount that only
+ *   appears afterwards then lands there too, instead of on a stale offset.
+ */
+export declare function rememberPanelView(sessionId: string | undefined, view: {
+    fileId: string;
+    scrollTop?: number | undefined;
+}): void;
+/**
+ * The file a session's panel was last showing.
+ * @param sessionId - the session, if any.
+ * @returns the pending entry id, or undefined when that session's panel has never
+ *   closed on a file.
+ */
+export declare function lastPanelFile(sessionId: string | undefined): string | undefined;
+/**
+ * How far down one file was left, when it has been left before.
+ * @param sessionId - the session, if any.
+ * @param fileId - the pending entry id.
+ * @returns the remembered scrollTop, or undefined when there is none.
+ */
+export declare function panelFileOffset(sessionId: string | undefined, fileId: string): number | undefined;
+/**
+ * Forget every session's record. A page reload does this by itself; a test calls
+ * it to start from a clean page rather than inheriting the previous case's place.
+ */
+export declare function resetPanelMemory(): void;