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

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,54 @@
+/**
+ * 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 { 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;
+    /** 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/ChangesTab.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import type { ForgeChangeRequestDiff, ForgeLocalDiff, ForgeLocalScope } from '../types.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 {
+    /** 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, 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,75 @@
+/**
+ * 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 { 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;
+    /** 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[];
+    /** Copy the repository-relative path from the file header. */
+    readonly onCopyPath: () => void;
+    /** 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/ForgeTab.d.ts

@@ -0,0 +1,54 @@
+/** 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 { 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>;
+    /** 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 while the
+ * `branch` scope changes files and no open change request has the checked-out
+ * branch as its head. 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, 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 changes before a change request carries
+ * them: the files the `branch` scope changes, their size, which opens the
+ * changes view, and the action that 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/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/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

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

@@ -0,0 +1,42 @@
+/** New Session option: start the Session in a new worktree, from a chosen local branch. */
+import { type ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ForgeBranches } from '../types.ts';
+import type { NS } from './locales.ts';
+import type { PanelSnapshot } from './source.ts';
+/** Business face of the New Session option. */
+export interface WorktreeToggleInjected {
+    /** Panel snapshot of the Session; the renderer binds it as `usePanel`. */
+    readonly hooks: {
+        readonly panel: HostObservable<PanelSnapshot>;
+    };
+    /**
+     * Request a worktree from a base branch, replacing an open request.
+     * @param from - base branch, or null for HEAD.
+     * @returns whether the Host accepted it.
+     */
+    readonly request: (from: string | null) => Promise<boolean>;
+    /**
+     * Withdraw the open request.
+     * @returns whether the Host accepted it.
+     */
+    readonly cancel: () => Promise<boolean>;
+    /**
+     * List the local branches of the Session's checkout.
+     * @returns the branches, or undefined when they could not be read.
+     */
+    readonly branches: () => Promise<ForgeBranches | undefined>;
+}
+/** Full props of the New Session option. */
+export type WorktreeToggleProps = InjectFace<WorktreeToggleInjected> & PropsLocale<typeof NS>;
+/**
+ * Render the worktree option while the Session can still start in a worktree:
+ * the base branch menu once requested, then the checkbox. When the checkout
+ * cannot host a worktree, the tooltip gives the reason and the checkbox only
+ * withdraws an open request. Both stay fixed while the worktree is being
+ * created.
+ * @param props - panel snapshot hook, request actions, and copy.
+ * @returns the option, or nothing once a turn started, the request settled, or no worktree service is mounted.
+ */
+export declare function WorktreeToggle({ usePanel, request, cancel, branches, t }: WorktreeToggleProps): ReactNode;
+//# sourceMappingURL=WorktreeToggle.d.ts.map

package/lib/types/client/changes-address.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The changes view's tab type: the right-Sidebar view of one Session's local
+ * changes or of one change request bound to it. Its addresses name the Session
+ * and the source, `dsh-resource://forge-changes/<session>/local` or
+ * `dsh-resource://forge-changes/<session>/change/<url>`, each part
+ * percent-encoded; the source names the tab.
+ */
+import type { SidebarRightTabDefinition } from '@deepseek-ai/dsh-client-ui-sidebar-right/client';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { NS } from './locales.ts';
+/** Kind of the changes tab. */
+export declare const CHANGES_KIND = "forge-changes";
+/** Registry id of the changes tab type, also the key its body and title register under. */
+export declare const CHANGES_ID = "@deepseek-ai/dsh-experimental-client-ui-forge/changes";
+/** What a changes view shows. */
+export type ChangesSource = 
+/** The changes of the Session's checkout. */
+{
+    readonly kind: 'local';
+}
+/** The changes of one change request bound to the Session, by its binding URL. */
+ | {
+    readonly kind: 'change';
+    readonly url: string;
+};
+/** The Session and the source one address names. */
+export interface ChangesTarget {
+    /** Session whose checkout or binding the view reads. */
+    readonly sessionId: SessionId;
+    /** What the view shows. */
+    readonly source: ChangesSource;
+}
+/** Navigation parameters of a changes tab. */
+export interface ChangesParams {
+    /** File to scroll to, by its path in the diff. */
+    readonly path?: string;
+}
+declare module '@deepseek-ai/dsh-client-ui-sidebar-right/client' {
+    interface SidebarRightResourceParamsMap {
+        /** The file a changes tab scrolls to. */
+        'forge-changes': ChangesParams;
+    }
+}
+/**
+ * Mint the address of a changes view.
+ * @param target - Session and source.
+ * @returns the `dsh-resource://forge-changes/…` address.
+ */
+export declare function changesAddress(target: ChangesTarget): string;
+/**
+ * Read the Session and source back out of a changes address.
+ * @param address - a resource address.
+ * @returns the target, or undefined for an address this package did not mint.
+ */
+export declare function parseChangesAddress(address: string): ChangesTarget | undefined;
+/**
+ * Name a changes view: 变更 for the local changes, #N 的变更 for a change request with a number.
+ * @param source - what the view shows.
+ * @param t - forge panel copy.
+ * @returns the title in the current language.
+ */
+export declare function changesTitle(source: ChangesSource, t: TranslateNS<typeof NS>): string;
+/**
+ * The changes type's registry definition.
+ * @param t - forge panel copy, read on every title call.
+ * @returns the definition to register.
+ */
+export declare function changesDefinition(t: TranslateNS<typeof NS>): SidebarRightTabDefinition;
+//# sourceMappingURL=changes-address.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * Choices of each changes tab: the local scope, the side-by-side view, line
+ * wrapping, and the navigation it last applied. One bucket per tab, so two
+ * views in one Session keep their own choices; the bucket ends with the tab
+ * record's signal.
+ */
+import { type EngineStoreHandle } from '@deepseek-ai/dsh-client-store';
+import type { ForgeLocalScope } from '../types.ts';
+/** One changes tab's choices. */
+export interface ChangesTabState {
+    /** Local changes shown; a change request view ignores it. */
+    scope: ForgeLocalScope['kind'];
+    /** Whether deletions and additions show in two columns. */
+    split: boolean;
+    /** Whether long lines wrap instead of being cut at the column edge. */
+    wrap: boolean;
+    /** The navigation revision last applied, whose file the view scrolled to. */
+    navigated: number;
+}
+/** Every changes tab's choices, keyed by tab id. */
+export interface ChangesState {
+    byTab: Record<string, ChangesTabState>;
+}
+/** The changes store's write set; every action names the tab it writes. */
+type ChangesActions = {
+    navigated: (draft: ChangesState, tabId: string, revision: number) => void;
+    scoped: (draft: ChangesState, tabId: string, scope: ForgeLocalScope['kind']) => void;
+    toggledSplit: (draft: ChangesState, tabId: string) => void;
+    toggledWrap: (draft: ChangesState, tabId: string) => void;
+    forget: (draft: ChangesState, tabId: string) => void;
+};
+/**
+ * Declare the changes tab's store; the registration declares it as an
+ * exclusive store, so the framework mints one instance per Session.
+ * @returns the store handle to declare on the registration.
+ */
+export declare function createChangesStore(): EngineStoreHandle<ChangesState, ChangesActions>;
+export {};
+//# sourceMappingURL=changes-store.d.ts.map