@deepseek-ai/dsh-experimental-client-ui-forge 0.0.0-stage → 0.2.2-alpha.3

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

@@ -0,0 +1,14 @@
+/** App-wide notice for forge panel actions, rendered outside the panel so it outlives it. */
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { NS } from './locales.ts';
+import type { NoticeSource } from './source.ts';
+/** Full props of the `shell.overlay` entry. */
+export type ActionToastProps = PropsLocale<typeof NS> & InjectFace<Omit<NoticeSource, 'report'>>;
+/**
+ * Render the current notice: a success notice with its undo action, or a failure warning.
+ * @param props - notice hook, dismissal, and copy.
+ * @returns the toast, or nothing while no notice shows.
+ */
+export declare function ActionToast({ useNotice, dismiss, t }: ActionToastProps): ReactNode;
+//# sourceMappingURL=ActionToast.d.ts.map

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

@@ -0,0 +1,56 @@
+/**
+ * One change request as a card: its title links to the host, a one-line
+ * summary shows while collapsed, and while expanded one row per fact (checks,
+ * review, merge state, and the changed lines, which open its changes) above
+ * the ready-for-review or merge action.
+ */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ChangeRequestSnapshot, MergeRequest } from '@deepseek-ai/dsh-experimental-forge/types';
+import type { ForgePanelChangeRequest } from '../types.ts';
+import type { NS } from './locales.ts';
+type Translate = PropsLocale<typeof NS>['t'];
+/** What a card can do; a surface without a Session binding omits `remove`, `markReady`, `merge`, and `viewChanges`. */
+export interface ChangeRequestActions {
+    /** Open a URL outside the app. */
+    readonly openLink: (url: string) => void;
+    /** Copy a URL to the clipboard. */
+    readonly copyLink: (url: string) => void;
+    /** Read the status again after a failed read. */
+    readonly retry: () => void;
+    /** Remove the change request from its Session. */
+    readonly remove?: ((entry: ForgePanelChangeRequest) => void) | undefined;
+    /** Mark a draft ready for review; settles once the outcome is reported. */
+    readonly markReady?: ((entry: ForgePanelChangeRequest) => Promise<void>) | undefined;
+    /** Merge the change request as `request` describes; settles once the outcome is reported. */
+    readonly merge?: ((entry: ForgePanelChangeRequest, request: MergeRequest) => Promise<void>) | undefined;
+    /** Load complete check details independently of polling; cancellation follows the open list. */
+    readonly readChecks?: ((url: string, headSha: string, signal: AbortSignal) => Promise<ChangeRequestSnapshot>) | undefined;
+    /** Open the changes view of the change request. */
+    readonly viewChanges?: ((entry: ForgePanelChangeRequest) => void) | undefined;
+}
+/** Props of one change request card. */
+export interface ChangeRequestCardProps {
+    /** Change request with its latest snapshot and polling result. */
+    readonly entry: ForgePanelChangeRequest;
+    /** Whether the details show. */
+    readonly expanded: boolean;
+    /** Show or hide the details. */
+    readonly onToggle: () => void;
+    /** Current epoch milliseconds for relative times. */
+    readonly now: number;
+    /** Card actions. */
+    readonly actions: ChangeRequestActions;
+    /** Active UI language for numeric formatting. */
+    readonly locale: string;
+    /** Forge panel copy. */
+    readonly t: Translate;
+}
+/**
+ * Render one change request.
+ * @param props - change request, expansion, current time, actions, and copy.
+ * @returns the card.
+ */
+export declare function ChangeRequestCard({ entry, expanded, onToggle, now, actions, locale, t }: ChangeRequestCardProps): ReactNode;
+export {};
+//# sourceMappingURL=ChangeRequestCard.d.ts.map

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

@@ -0,0 +1,36 @@
+/** Changed-file navigation shared by the toolbar menu and wide diff pane, with a disclosure column on every row. */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ForgeDiffFile } from '../types.ts';
+import type { NS } from './locales.ts';
+/** Viewing choices remain owned by the changes tab while either navigation surface is hidden. */
+export interface ChangedFilesState {
+    readonly query: string;
+    readonly collapsed: Readonly<Record<string, boolean>>;
+    readonly selected: string | null;
+}
+/** Data and actions of the changed-file navigator. */
+export interface ChangedFilesProps extends PropsLocale<typeof NS> {
+    readonly files: readonly ForgeDiffFile[];
+    readonly state: ChangedFilesState;
+    readonly filter: (query: string) => void;
+    readonly toggle: (path: string) => void;
+    readonly jump: (path: string) => void;
+    /** A menu row participates in the shared menu's keyboard walk. */
+    readonly menu?: boolean;
+}
+/**
+ * Render searchable directory navigation without reading file contents.
+ * @param props - changed files, per-tab choices, navigation actions, and localized copy.
+ * @returns the search field and matching branches.
+ */
+export declare function ChangedFiles(props: ChangedFilesProps): ReactNode;
+/**
+ * Open directory navigation through the existing files toolbar entry.
+ * @param props - navigator data and whether its owning tab is visible.
+ * @returns the toolbar entry and its portalled menu.
+ */
+export declare function ChangedFilesMenu({ visible, ...props }: ChangedFilesProps & {
+    readonly visible: boolean;
+}): ReactNode;
+//# sourceMappingURL=ChangedFiles.d.ts.map

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

@@ -0,0 +1,59 @@
+/**
+ * Body of the changes tab: the local changes of the Session's checkout in a
+ * chosen scope, or the changes of one of its change requests, as one list of
+ * file sections under a toolbar that jumps between files and switches the
+ * layout. The view reads the changes when it opens, on each navigation, on
+ * refresh, and when the change request's head or the checkout's `branch`
+ * scope summary changes; a read keeps the previous changes on screen until it settles.
+ */
+import { type ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale, PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SidebarRightTabInfo } from '@deepseek-ai/dsh-client-ui-sidebar-right/client';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { ForgeChangeRequestDiff, ForgeLocalDiff, ForgeLocalScope } from '../types.ts';
+import type { ForgeReviewRequest, ForgeReviewResult } from '@deepseek-ai/dsh-experimental-forge/types';
+import { type ReviewQueue } from './review-queue.ts';
+import type { ReviewSelection } from './review.ts';
+import type { createChangesStore } from './changes-store.ts';
+import type { ForgePanelKey, NS } from './locales.ts';
+import type { PanelSnapshot } from './source.ts';
+/** Business face of the changes tab body. */
+export interface ChangesTabInjected {
+    /** Append a frozen comment to the main input without submitting it. */
+    readonly addReviewToInput: (selection: ReviewSelection) => boolean;
+    /** Records retained across Session switches and cleared when this tab occurrence closes. */
+    readonly reviewQueue: (tab: Pick<SidebarRightTabInfo['tab'], 'id' | 'signal'>) => ReviewQueue;
+    /** Publish one comment or a completed review; never retries mutations. */
+    readonly submitReview: (url: string, request: ForgeReviewRequest) => Promise<RemoteResult<ForgeReviewResult>>;
+    /** Panel source while visible; the renderer releases the subscription for an inactive key. */
+    readonly keyedHooks: {
+        readonly panel: (visibility: string) => HostObservable<PanelSnapshot> | undefined;
+    };
+    /** Open the panel stream again after it ended. */
+    readonly reconnect: () => void;
+    /** Read the local changes of one scope; `signal` aborts the read. */
+    readonly localDiff: (scope: ForgeLocalScope, signal: AbortSignal) => Promise<RemoteResult<ForgeLocalDiff>>;
+    /** Read the new side of one file in a local scope. */
+    readonly localText: (scope: ForgeLocalScope, path: string) => Promise<RemoteResult<string>>;
+    /** Read the changes of a change request by its binding URL; `signal` aborts the read. */
+    readonly changeRequestDiff: (url: string, signal: AbortSignal) => Promise<RemoteResult<ForgeChangeRequestDiff>>;
+    /** Read one file of a change request at a commit. */
+    readonly changeRequestText: (url: string, commit: string, path: string) => Promise<RemoteResult<string>>;
+    /** Open a URL outside the app. */
+    readonly openLink: (url: string) => void;
+    /** Copy a path to the clipboard and report the outcome. */
+    readonly copyPath: (path: string) => void;
+    /** Ask the Session's Agent to create a change request for its changes, reporting the outcome. */
+    readonly createChangeRequest: () => void;
+    /** Show a failure notice. */
+    readonly report: (key: ForgePanelKey, params?: Readonly<Record<string, string>>) => void;
+}
+/** Full props of the changes tab body. */
+export type ChangesTabProps = Pick<PropsRuntime<'sidebar.right.pane.tab'>, 'useTabInfo' | 'sessionId'> & PropsStore<ReturnType<typeof createChangesStore>> & InjectFace<ChangesTabInjected> & PropsLocale<typeof NS>;
+/**
+ * Render the changes tab of one Session.
+ * @param props - tab information, the tab's choices, the panel snapshot hook, reads and actions, and copy.
+ * @returns the view body.
+ */
+export declare function ChangesTab({ useTabInfo, sessionId, useStore, actions, usePanel, reconnect, localDiff, localText, changeRequestDiff, changeRequestText, openLink, copyPath, createChangeRequest, addReviewToInput, reviewQueue, submitReview, report, t, }: ChangesTabProps): ReactNode;
+//# sourceMappingURL=ChangesTab.d.ts.map

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

@@ -0,0 +1,13 @@
+/** Chip title of a changes tab: the changes icon and the view's name in the current language. */
+import type { ReactNode } from 'react';
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { NS } from './locales.ts';
+/** Props of the changes tab title. */
+export type ChangesTabTitleProps = Pick<PropsRuntime<'sidebar.right.pane.tab.title'>, 'useTabInfo'> & PropsLocale<typeof NS>;
+/**
+ * Render the chip title of a changes tab; an address this package did not mint keeps the captured title.
+ * @param props - tab information and forge panel copy.
+ * @returns the icon followed by the title.
+ */
+export declare function ChangesTabTitle({ useTabInfo, t }: ChangesTabTitleProps): ReactNode;
+//# sourceMappingURL=ChangesTabTitle.d.ts.map

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

@@ -0,0 +1,76 @@
+/**
+ * One file of the changes view: a sticky header with the path, badges, line
+ * counts, and file actions, then its hunks unified or side by side with the
+ * unchanged lines between them collapsed into rows that expand them.
+ */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ForgeDiffFile } from '../types.ts';
+import { type ReviewActions } from './ReviewComposer.tsx';
+import type { ForgePanelKey, NS } from './locales.ts';
+type Translate = PropsLocale<typeof NS>['t'];
+/** One action of a file's menu. */
+export interface DiffFileAction {
+    /** Dictionary key of the row label. */
+    readonly label: ForgePanelKey;
+    /** Runs the action. */
+    readonly run: () => void;
+}
+/** New side of a file: its lines once read, `loading` while a read runs, or undefined before any. */
+export type DiffFileText = readonly string[] | 'loading' | undefined;
+/** Props of one file section. */
+export interface DiffFileProps {
+    /** Whether the owning tab is visible and may show temporary menus. */
+    readonly visible: boolean;
+    /** Comment destinations and the source being reviewed. */
+    readonly review?: ReviewActions;
+    /** The file and its hunks. */
+    readonly file: ForgeDiffFile;
+    /** Whether the section shows its lines. */
+    readonly expanded: boolean;
+    /** Expand or collapse the section. */
+    readonly onToggle: () => void;
+    /** Whether the file shows the large-file notice instead of its lines until revealed. */
+    readonly large: boolean;
+    /** Whether the user revealed a large file. */
+    readonly revealed: boolean;
+    /** Show a large file anyway. */
+    readonly onReveal: () => void;
+    /** The file's new side, which supplies collapsed unchanged lines. */
+    readonly text: DiffFileText;
+    /** Indexes of the expanded gaps. */
+    readonly open: ReadonlySet<number>;
+    /** Expand one gap. */
+    readonly onExpand: (index: number) => void;
+    /** Whether deletions and additions show in two columns; a file with only additions or only deletions keeps one. */
+    readonly split: boolean;
+    /** Whether long lines wrap. */
+    readonly wrap: boolean;
+    /** Badge text after the path, or empty for none. */
+    readonly badge: string;
+    /** Hover text of the path: both paths of a renamed file, else the path. */
+    readonly tooltip: string;
+    /** Rows of the file's menu. */
+    readonly actions: readonly DiffFileAction[];
+    /** Receives the section element, which scrolling to the file targets. */
+    readonly sectionRef: (element: HTMLElement | null) => void;
+    /** Forge panel copy. */
+    readonly t: Translate;
+}
+/**
+ * Render added and deleted line counts, or the binary label for binary content.
+ * @param props - the counts and copy.
+ * @returns the counts.
+ */
+export declare function Counts({ file, t }: {
+    readonly file: Pick<ForgeDiffFile, 'additions' | 'deletions' | 'binary'>;
+    readonly t: Translate;
+}): ReactNode;
+/**
+ * Render one file of a diff.
+ * @param props - the file, its section and gap state, layout choices, menu actions, and copy.
+ * @returns the file section.
+ */
+export declare function DiffFile(props: DiffFileProps): ReactNode;
+export {};
+//# sourceMappingURL=DiffFile.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * The label of a changed file in the files menu, the local changes list, and a
+ * file's header: its name, then its directory in smaller subdued type, with the
+ * complete path in a tooltip.
+ */
+import type { ReactNode } from 'react';
+/**
+ * Render a changed file's name and directory. The directory gives up its space
+ * before the name does; assistive technology reads the complete path.
+ * @param props.path - the file's path in the repository.
+ * @param props.tooltip - the hover text, such as both paths of a renamed file; defaults to the path.
+ * @param props.className - class of the outer element, which callers size within their row.
+ * @returns the label.
+ */
+export declare function FileLabel({ path, tooltip, className }: {
+    readonly path: string;
+    readonly tooltip?: string | undefined;
+    readonly className?: string | undefined;
+}): ReactNode;
+//# sourceMappingURL=FileLabel.d.ts.map

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

@@ -0,0 +1,15 @@
+/** Resizable file navigation; width belongs to the mounted tab and survives hiding the pane. */
+import { type ReactNode } from 'react';
+import { type ChangedFilesProps } from './ChangedFiles.tsx';
+/** Placement of a tab's file navigator; hiding it retains its viewing choices. */
+export type FileTreePosition = 'right' | 'left' | 'hidden';
+/**
+ * Render a keyboard- and pointer-resizable tree beside the diff.
+ * @param props - tree rows, pane position, and the toggle's controlled element id.
+ * @returns the bounded pane and its resize separator.
+ */
+export declare function FileTreePane({ position, id, ...props }: ChangedFilesProps & {
+    readonly position: FileTreePosition;
+    readonly id: string;
+}): ReactNode;
+//# sourceMappingURL=FileTreePane.d.ts.map

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

@@ -0,0 +1,57 @@
+/** Body of the forge sidebar tab: where the Session works, its local changes, and the change requests it created or pushed. */
+import { type ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { RemoteHostFacts } from '@deepseek-ai/dsh-api-remotes/client';
+import type { MergeRequest } from '@deepseek-ai/dsh-experimental-forge/types';
+import type { ForgePanelChangeRequest } from '../types.ts';
+import { type ChangeRequestActions } from './ChangeRequestCard.tsx';
+import type { NS } from './locales.ts';
+import type { PanelSnapshot } from './source.ts';
+/** Business face of the tab body. */
+export interface ForgeTabInjected {
+    /** Panel snapshot of the Session and the Host facts; the renderer binds them as `usePanel` and `useHost`. */
+    readonly hooks: {
+        readonly panel: HostObservable<PanelSnapshot>;
+        readonly host: HostObservable<RemoteHostFacts>;
+        readonly locale: HostObservable<string>;
+    };
+    /** Open the stream again after it ended. */
+    readonly reconnect: () => void;
+    /**
+     * Reinspect the checkout, probe sign-in, and poll the change requests;
+     * settles once the Host has inspected and probed, after reporting a failure.
+     */
+    readonly refresh: () => Promise<void>;
+    /** Remove a change request from the Session, offering to undo it. */
+    readonly remove: (entry: ForgePanelChangeRequest) => void;
+    /** Mark a draft ready for review; settles once the outcome is reported. */
+    readonly markReady: (entry: ForgePanelChangeRequest) => Promise<void>;
+    /** Merge a change request as `request` describes; settles once the outcome is reported. */
+    readonly merge: (entry: ForgePanelChangeRequest, request: MergeRequest) => Promise<void>;
+    /** Read the complete checks of an opened change request. */
+    readonly readChecks: NonNullable<ChangeRequestActions['readChecks']>;
+    /** Check the removed worktree of the Session out again, reporting the outcome. */
+    readonly restore: () => void;
+    /** Open a URL outside the app. */
+    readonly openLink: (url: string) => void;
+    /** Copy text to the clipboard and report the outcome. */
+    readonly copyText: (text: string) => void;
+    /** Copy a path to the clipboard and report the outcome. */
+    readonly copyPath: (path: string) => void;
+    /** Record whether the tab is visible, for the header entry's pressed state. */
+    readonly reportVisible: (visible: boolean) => void;
+    /** Ask the Session's Agent to create a change request for its changes, reporting the outcome. */
+    readonly createChangeRequest: () => void;
+}
+/** Full props of the tab body. */
+export type ForgeTabProps = Pick<PropsRuntime<'sidebar.right.pane.tab'>, 'useTabInfo' | 'sessionId'> & InjectFace<ForgeTabInjected> & PropsLocale<typeof NS>;
+/**
+ * Render the forge tab of one Session. The local changes card shows whenever
+ * the `branch` scope changes files, independently of bound change requests.
+ * The only open change request starts expanded; once the
+ * user expands or collapses a card, the panel keeps that choice across later updates.
+ * @param props - tab information, panel snapshot and Host facts hooks, actions, and copy.
+ * @returns the tab body.
+ */
+export declare function ForgeTab({ useTabInfo, sessionId, usePanel, useHost, useLocale, reconnect, refresh, remove, markReady, merge, readChecks, restore, openLink, copyText, copyPath, reportVisible, createChangeRequest, t, }: ForgeTabProps): ReactNode;
+//# sourceMappingURL=ForgeTab.d.ts.map

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

@@ -0,0 +1,11 @@
+/** Chip title of the forge tab: the change request glyph and the localized tab name. */
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { NS } from './locales.ts';
+/**
+ * Render the tab chip title in the current UI language.
+ * @param props - forge panel copy.
+ * @returns the glyph followed by the tab name.
+ */
+export declare function ForgeTabTitle({ t }: PropsLocale<typeof NS>): ReactNode;
+//# sourceMappingURL=ForgeTabTitle.d.ts.map

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

@@ -0,0 +1,27 @@
+/** Session header entry that shows or hides the forge tab and marks change requests that need attention. */
+import type { ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { NS } from './locales.ts';
+import type { PanelSnapshot } from './source.ts';
+/** Business face of the header entry. */
+export interface HeaderButtonInjected {
+    /** Panel snapshot and tab visibility of the Session; the renderer binds them as `usePanel` and `useVisible`. */
+    readonly hooks: {
+        readonly panel: HostObservable<PanelSnapshot>;
+        readonly visible: HostObservable<boolean>;
+    };
+    /**
+     * Hide the forge tab when it is visible, otherwise open or reveal it.
+     * @param visible - whether the tab is visible now.
+     */
+    readonly toggle: (visible: boolean) => void;
+}
+/** Full props of the header entry. */
+export type HeaderButtonProps = InjectFace<HeaderButtonInjected> & PropsLocale<typeof NS>;
+/**
+ * Render the header entry.
+ * @param props - panel snapshot and visibility hooks, the toggle, and copy.
+ * @returns the entry, or nothing outside a Git checkout without bound change requests.
+ */
+export declare function HeaderButton({ usePanel, useVisible, toggle, t }: HeaderButtonProps): ReactNode;
+//# sourceMappingURL=HeaderButton.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * The panel card of the checkout's `branch` scope changes, independent of
+ * change request bindings: file counts and paths open the local changes view,
+ * and an optional action asks the Agent for a change request.
+ */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ForgeLocalChanges } from '../types.ts';
+import type { NS } from './locales.ts';
+/** Props of the local changes card. */
+export interface LocalChangesCardProps {
+    /** Files the `branch` scope changes and the ref it compares with. */
+    readonly local: ForgeLocalChanges;
+    /** Whether the card offers to create a change request. */
+    readonly creatable: boolean;
+    /** Open the changes view, scrolled to `path` when given. */
+    readonly view: (path?: string) => void;
+    /** Ask the Agent to create a change request for the changes. */
+    readonly create: () => void;
+    /** Forge panel copy. */
+    readonly t: PropsLocale<typeof NS>['t'];
+}
+/**
+ * Render the local changes card; the file list starts collapsed.
+ * @param props - the changes, the view and create actions, and copy.
+ * @returns the card.
+ */
+export declare function LocalChangesCard({ local, creatable, view, create, t }: LocalChangesCardProps): ReactNode;
+//# sourceMappingURL=LocalChangesCard.d.ts.map

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

@@ -0,0 +1,18 @@
+/** Refresh glyph that turns while a refresh runs. */
+import { type ReactNode } from 'react';
+/** Props of the refresh glyph. */
+export interface RefreshGlyphProps {
+    /** Whether the refresh runs. */
+    readonly busy: boolean;
+    /** Glyph size in pixels. */
+    readonly size: number;
+}
+/**
+ * Render the refresh glyph. It turns while `busy` and, once `busy` ends,
+ * completes the turn under way, so a quick refresh still shows a whole turn
+ * and the glyph stops upright. Under reduced motion it dims and returns instead of turning.
+ * @param props - whether the refresh runs, and the glyph size.
+ * @returns the glyph.
+ */
+export declare function RefreshGlyph({ busy, size }: RefreshGlyphProps): ReactNode;
+//# sourceMappingURL=RefreshGlyph.d.ts.map

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

@@ -0,0 +1,40 @@
+/** Plain-text comment editor for a frozen selection in either review tab. */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ReviewQueue } from './review-queue.ts';
+import type { ReviewSelection, ReviewSource } from './review.ts';
+import type { NS } from './locales.ts';
+/** Actions supplied by the owning changes tab. */
+export interface ReviewActions {
+    /** The source currently displayed; selecting a range freezes it. */
+    readonly source: ReviewSource;
+    /** Browser records shared by the changes tab. */
+    readonly records?: ReviewQueue;
+    /** Whether another comment already started a pending review. */
+    readonly reviewStarted?: boolean;
+    /** Open the confirmed publication URL. */
+    readonly openLink?: (url: string) => void;
+    /** A write is running or its outcome still needs confirmation. */
+    readonly publishingBlocked?: boolean;
+    /** Append an atomic quote without sending the Agent a message. */
+    readonly addToInput: (selection: ReviewSelection) => boolean;
+    /** Retain a new comment after its quote was accepted. */
+    readonly onQuoted?: (selection: ReviewSelection) => void;
+    /** Publish one comment; an error string preserves the editor. */
+    readonly publish?: (selection: ReviewSelection) => Promise<string | undefined>;
+    /** Keep one comment for the final review; false preserves the editor. */
+    readonly queue?: (selection: ReviewSelection) => boolean;
+}
+/**
+ * Render the line range, plain-text editor, and explicitly named destinations.
+ * @param props - frozen selection, actions, cancellation, and localized copy.
+ * @returns the inline comment form.
+ */
+export declare function ReviewComposer({ selection, actions, close, visible, split, t }: PropsLocale<typeof NS> & {
+    readonly visible?: boolean;
+    readonly split?: boolean;
+    readonly selection: ReviewSelection;
+    readonly actions: ReviewActions;
+    readonly close: () => void;
+}): ReactNode;
+//# sourceMappingURL=ReviewComposer.d.ts.map

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

@@ -0,0 +1,26 @@
+/** Inline comment records and editing of a pending review at its captured code location. */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ReviewActions } from './ReviewComposer.tsx';
+import { type FileReviewState, type ReviewThread as Thread } from './review-queue.ts';
+import type { NS } from './locales.ts';
+/**
+ * Subscribe only to comments that belong to the displayed file and source.
+ * @param actions - review actions and their browser store.
+ * @param path - displayed file path.
+ * @returns stable file-scoped comments and write availability.
+ */
+export declare function useFileReview(actions: ReviewActions | undefined, path: string): FileReviewState;
+/**
+ * Render a saved comment at its line, with pending edits kept in the browser queue.
+ * @param props - record, edit availability, source actions, and localized copy.
+ * @returns one compact inline comment card.
+ */
+export declare function ReviewThread({ thread, actions, locked, outdated, split, t }: PropsLocale<typeof NS> & {
+    readonly thread: Thread;
+    readonly actions: ReviewActions;
+    readonly locked: boolean;
+    readonly outdated: boolean;
+    readonly split: boolean;
+}): ReactNode;
+//# sourceMappingURL=ReviewThread.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * The forge section of a Session row's hover card: the worktree branch while
+ * the Session works in the worktree the panel created for it, and its change
+ * requests, most urgent first.
+ */
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { NS } from './locales.ts';
+import { type SessionListInjected } from './session-list.ts';
+/** Change requests the hover card lists before naming how many more there are. */
+export declare const HOVER_CHANGE_REQUEST_LIMIT = 3;
+/** Full props of the hover section. */
+export type SessionHoverForgeProps = PropsRuntime<'sidebar.session.row.hover'> & PropsLocale<typeof NS> & InjectFace<SessionListInjected>;
+/**
+ * Render the forge section of a Session's hover card.
+ * @param props - the row's Session, the shared hooks, and copy.
+ * @returns the section, or null for a Session without a worktree or change requests.
+ */
+export declare function SessionHoverForge({ sessionId, useSessions, useStates, t }: SessionHoverForgeProps): ReactNode;
+//# sourceMappingURL=SessionHoverForge.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * Session row icons after the time label: a branch glyph while the Session
+ * works in the worktree the panel created for it, and the state glyph of its
+ * most urgent change request. Glyphs of open change requests stay in the
+ * row's subdued color with a dot for their checks; merged and closed ones keep
+ * their state color.
+ */
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ChecksRollup } from '@deepseek-ai/dsh-experimental-forge/types';
+import type { ForgePanelKey, NS } from './locales.ts';
+import { type SessionListChangeRequest, type SessionListInjected } from './session-list.ts';
+type Translate = PropsLocale<typeof NS>['t'];
+/** Copy of each checks outcome a row and its hover card name. */
+export declare const CHECKS_LABEL: Record<Exclude<ChecksRollup, 'none'>, ForgePanelKey>;
+/**
+ * The checks outcome a row shows for a change request: none for a merged,
+ * closed, or not yet polled one.
+ * @param entry - the change request.
+ * @returns the outcome.
+ */
+export declare function rowChecks(entry: SessionListChangeRequest): ChecksRollup;
+/**
+ * Name a change request's state and checks, as one line.
+ * @param entry - the change request.
+ * @param t - forge panel copy.
+ * @returns the line.
+ */
+export declare function stateLine(entry: SessionListChangeRequest, t: Translate): string;
+/** Full props of the row icons. */
+export type SessionRowForgeProps = PropsRuntime<'sidebar.session.row.trailing'> & PropsLocale<typeof NS> & InjectFace<SessionListInjected>;
+/**
+ * Render a Session row's forge icons.
+ * @param props - the row's Session, the shared hooks, and copy.
+ * @returns the icons, or nothing for a Session without a worktree or change requests.
+ */
+export declare function SessionRowForge({ sessionId, useSessions, useStates, t }: SessionRowForgeProps): ReactNode;
+export {};
+//# sourceMappingURL=SessionRowForge.d.ts.map

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

@@ -0,0 +1,22 @@
+/** Centered review submission with a summary, decision, and pending-comment count. */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ReviewQueue } from './review-queue.ts';
+import type { NS } from './locales.ts';
+/**
+ * Submit a review independently of the diff scroll position; comments remain at their code locations.
+ * @param props - durable queue, current head, submission outcome, and modal actions.
+ * @returns a portalled modal with keyboard focus ownership.
+ */
+export declare function SubmitReview({ queue, url, headSha, busy, error, submit, close, check, reconcile, t }: PropsLocale<typeof NS> & {
+    readonly queue: ReviewQueue;
+    readonly url: string;
+    readonly headSha: string;
+    readonly busy: boolean;
+    readonly error: string | null;
+    readonly submit: () => void;
+    readonly close: () => void;
+    readonly check: () => void;
+    readonly reconcile: () => void;
+}): ReactNode;
+//# sourceMappingURL=SubmitReview.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * Card above the composer while a Session's worktree is created, while a message
+ * waits after a failed or stopped attempt, and when its worktree is gone or
+ * being restored.
+ */
+import { type ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { NS } from './locales.ts';
+import type { PanelSnapshot } from './source.ts';
+/** Business face of the card. */
+export interface WorktreeProgressInjected {
+    /** Panel snapshot of the Session; the renderer binds it as `usePanel`. */
+    readonly hooks: {
+        readonly panel: HostObservable<PanelSnapshot>;
+    };
+    /** Stop the running attempt a message waits for; the message keeps waiting. */
+    readonly stop: () => void;
+    /** Make another attempt at the worktree a message waits for. */
+    readonly retry: () => void;
+    /** Withdraw the worktree request, so the waiting message goes on without a worktree. */
+    readonly withdraw: () => void;
+    /**
+     * Check out the removed worktree again.
+     * @returns the failure text, or undefined once it is restored.
+     */
+    readonly restore: () => Promise<string | undefined>;
+    /** Move the Session back to the source checkout of its removed worktree. */
+    readonly leave: () => void;
+}
+/** Full props of the card. */
+export type WorktreeProgressProps = InjectFace<WorktreeProgressInjected> & PropsLocale<typeof NS>;
+/**
+ * Render the worktree card of a Session: the running attempt at its
+ * requested worktree, which can be stopped while a message waits for it; the
+ * failed or stopped attempt a message waits after, with another attempt or
+ * withdrawing the request so the message goes on without a worktree; or the
+ * removal of the worktree the Session works in, with restoring it, whose
+ * steps the card follows, and returning to the source checkout, after which
+ * a waiting message goes on.
+ * @param props - panel hook, actions, and copy.
+ * @returns the card, or nothing while no attempt runs, no message waits, and the worktree exists.
+ */
+export declare function WorktreeProgress({ usePanel, stop, retry, withdraw, restore, leave, t }: WorktreeProgressProps): ReactNode;
+//# sourceMappingURL=WorktreeProgress.d.ts.map