dsh-diff-approval 0.20.1 → 0.21.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/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,177 @@
+/**
+ * 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";
+/** 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;
+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,29 @@ 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;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;
@@ -166,6 +197,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 +249,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 +263,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 +285,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 +314,29 @@ 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;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;

package/lib/types/client/presentation-menu.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The mode switch: where the panel shows — floating over the app, or docked as a
+ * tab in the app's right sidebar. (What the floating panel *covers* is the
+ * coverage control's business; see the panel's own header.)
+ *
+ * One implementation, two hosts. The floating panel draws it in its own header
+ * beside the gear. A *docked* panel draws no header at all — the tab is the
+ * frame, its chip already carries the title and a close button — so the chip
+ * (`sidebar.right.pane.tab.title`, which is this plugin's own component) hosts
+ * the same control instead: the seat's convention is a glyph *before* the title
+ * text, and the chip's tail is masked for the kit's own close button.
+ *
+ * @module dsh-diff-approval/client/presentation-menu
+ */
+import type { ReactNode } from 'react';
+import type { MenuEntry } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { DiffApprovalPresentation } from './settings.ts';
+import type { Translator } from './locales.ts';
+/**
+ * The mode switch's mark: the state it currently shows, and the same glyph each
+ * menu row leads with. The dock mark is the icon the app's own right sidebar uses
+ * (`IconPanelLeftOutline16`, mirrored — see ui-sidebar-right's ExpandButton), so
+ * "dock" points at the same affordance the column does.
+ * @param props - the state, and the drawn size in px.
+ * @returns the glyph.
+ */
+export declare function PresentationIcon({ state, size }: {
+    state: DiffApprovalPresentation;
+    size: number;
+}): ReactNode;
+export interface PresentationMenuProps {
+    t: Translator;
+    /** Where the panel is now: the checked row, and the mark on the trigger. */
+    current: DiffApprovalPresentation;
+    onChoose: (next: DiffApprovalPresentation) => void;
+    /** Rows pinned below a hairline, for a host with no other way to reach them
+     *  (the chip carries this plugin's Settings; a docked panel has no gear). */
+    footer?: readonly MenuEntry[];
+    /** Called for a `footer` row's id, which is not a presentation. */
+    onFooter?: (id: string) => void;
+    /** The chip's variant: no room for the chevron, and a box the chip's 28px
+     *  height can hold. */
+    compact?: boolean;
+}
+export declare function PresentationMenu({ t, current, onChoose, footer, onFooter, compact }: PresentationMenuProps): ReactNode;

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

@@ -1,4 +1,24 @@
 /** Client preferences for the review panel, persisted in localStorage. */
+/** Where the review panel shows: floating over the app, or docked as a tab in the
+ *  app's right sidebar. What the floating panel covers is a separate setting —
+ *  see {@link DiffApprovalCover}. */
+export type DiffApprovalPresentation = 'float' | 'dock';
+/**
+ * What the floating panel covers: the app's header above the conversation, its
+ * left sidebar, its right sidebar, and the composer below. All four on is the
+ * presentation the panel used to call "fullscreen" — the panel filling the
+ * window; both sidebars and the header only is the plain floating panel, which
+ * leaves the input usable.
+ */
+export interface DiffApprovalCover {
+    readonly top: boolean;
+    readonly left: boolean;
+    readonly right: boolean;
+    readonly composer: boolean;
+}
+/** The floating panel's default coverage: the header and both sidebars, not the
+ *  composer. */
+export declare const FLOAT_COVER_DEFAULT: DiffApprovalCover;
 /** Default lead rows above a jumped-to diff block (kept small and bounded). */
 export declare const NAV_LEAD_ROWS_DEFAULT = 2;
 export declare const NAV_LEAD_ROWS_MIN = 0;
@@ -61,6 +81,42 @@ export declare function setSearchCaseSensitive(value: boolean): void;
 export declare function searchWholeWord(): boolean;
 /** Persist the search whole-word preference. */
 export declare function setSearchWholeWord(value: boolean): void;
+/**
+ * Where the review panel shows, as the user last had it. Two states, both
+ * remembered so the footer entry can restore the one they were using:
+ *
+ * - `float` — the panel floating over the app, covering what
+ *   {@link panelCover} says (and the composer only when that says so);
+ * - `dock` — the panel docked in the app's right sidebar, as its own tab.
+ *
+ * A stored `fullscreen` — the third state before coverage became three switches —
+ * reads as `float`, with {@link panelCover} supplying the all-on coverage it
+ * meant.
+ * @returns the remembered presentation; `float` when unset or unrecognized.
+ */
+export declare function panelPresentation(): DiffApprovalPresentation;
+/** Persist the panel's presentation (see {@link panelPresentation}). */
+export declare function setPanelPresentation(value: DiffApprovalPresentation): void;
+/**
+ * What the floating panel covers (see {@link DiffApprovalCover}). Defaults to
+ * both sidebars and not the composer; a stored `fullscreen` presentation from
+ * before the switches means all three.
+ * @returns the remembered coverage.
+ */
+export declare function panelCover(): DiffApprovalCover;
+/** Window event: the floating panel's coverage changed (see {@link setPanelCover}). */
+export declare const COVER_CHANGED_EVENT = "diff-approval:cover";
+/** Persist what the floating panel covers. */
+export declare function setPanelCover(value: DiffApprovalCover): void;
+/**
+ * Whether the file list always folds into its floating card, whatever width the
+ * panel has. Defaults to off, where the width decides: the list sits beside the
+ * diff while there is room for both. Only an explicit `'1'` forces the fold.
+ * @returns whether the file list is always folded.
+ */
+export declare function fileListFloat(): boolean;
+/** Persist the always-fold preference for the file list. */
+export declare function setFileListFloat(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
@@ -171,7 +227,9 @@ export declare function quickSummonKey(): string;
 /** Persist the quick-summon chord. */
 export declare function setQuickSummonKey(value: string): void;
 /** Default chord for each configurable action (every supported key except the
- *  panel's own ESC-to-close, which is intentionally not remapped). */
+ *  panel's own ESC-to-close, which is intentionally not remapped). The coverage
+ *  switches are keyed like the edges they toggle, in the order the panel lists
+ *  them: left, top, right, bottom. */
 export declare const DEFAULT_KEYBINDINGS: Record<string, string>;
 /** The currently configured chord for one action; falls back to its default. */
 export declare function keybindingOf(action: string): string;