@benz-ai-x/dsh-md-preview 0.7.2 → 0.10.0

package/lib/types/client/preview-session.d.ts

@@ -3,7 +3,9 @@
  * lifecycle — content read, edit session, guarded save, prompts. The React
  * adapter lives beside the panel (use-preview-session.ts); effects and RPC
  * never enter here. `READ_STARTED` is the single reset point: a new read
- * begins only when the previous document's whole session is over.
+ * begins only when the previous document's whole session is over. Leaving
+ * with a dirty draft is asked about at the leave-intent seat (leave-intent.ts)
+ * before anything reaches this machine, so no unsaved prompt lives here.
  */
 import type { MdPreviewFile, MdPreviewWriteResult } from '../protocol.ts';
 /** Content lifecycle of one preview target. */
@@ -34,10 +36,10 @@ export interface PreviewSessionState {
         readonly code: string;
         readonly message: string;
     } | null;
-    /** The unsaved guard is asking before a close. */
-    readonly unsavedPrompt: boolean;
     /** The saved toast is showing. */
     readonly toast: boolean;
+    /** The write succeeded and the confirming re-read has not settled yet (#23). */
+    readonly savedPendingRead: boolean;
     /** The session asked the shell to close the panel; the adapter acts once. */
     readonly closeRequested: boolean;
 }
@@ -73,10 +75,6 @@ export type PreviewSessionAction = {
     readonly type: 'CANCEL_EDIT';
 } | {
     readonly type: 'REQUEST_CLOSE';
-} | {
-    readonly type: 'DISCARD';
-} | {
-    readonly type: 'KEEP_EDITING';
 } | {
     readonly type: 'TOAST_EXPIRED';
 };

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

@@ -0,0 +1,97 @@
+/**
+ * The reading record (#25): what lets a reopened document land back near
+ * where reading stopped. UI-local viewing state only — keyed by (session,
+ * path), holding nothing but position facts (section identity, offsets,
+ * fractions, timestamps); never a document body, draft, or fingerprint.
+ * The envelope is versioned, every loaded record is validated, and the
+ * collection is bounded. Storage damage or absence degrades to an empty
+ * (then in-memory) store — reading itself never depends on it.
+ */
+import type { OutlineEntry } from './outline.ts';
+/** Records kept at most; the oldest `at` evict first. */
+export declare const MAX_READING_RECORDS = 50;
+/** Envelope format version; an unknown version means an unreadable store. */
+export declare const READING_RECORD_VERSION = 1;
+/** The minimal persistence face the store needs (a subset of DOM Storage). */
+export interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+/** Section identity: the heading text plus its occurrence ordinal among same-text headings. */
+export interface ReadingAnchor {
+    readonly text: string;
+    readonly ordinal: number;
+}
+/** One document's reading position, as captured from the view face. */
+export interface ReadingPosition {
+    /** Capture time (ms epoch); recency order and eviction key. */
+    readonly at: number;
+    /** The section owning the reading line; null above the first heading. */
+    readonly anchor: ReadingAnchor | null;
+    /** The anchor's outline index at capture time (in-range fallback). */
+    readonly index: number;
+    /** Scroll offset below the anchor heading's top, in px. */
+    readonly offsetIntoSection: number;
+    /** Scroll fraction 0..1 — the fallback that survives any outline change. */
+    readonly fraction: number;
+}
+/** The panel-facing reading record store. */
+export interface ReadingStore {
+    /** The stored position of one document, or null without a usable record. */
+    get(sessionId: string, path: string): ReadingPosition | null;
+    /** Record (or overwrite) one document's position. */
+    record(sessionId: string, path: string, position: ReadingPosition): void;
+    /** The most recently read document of one session — the continue-reading target. */
+    latest(sessionId: string): {
+        readonly path: string;
+        readonly at: number;
+    } | null;
+    /** The session's documents by recency, most recent first (#31). */
+    recent(sessionId: string, limit: number): ReadonlyArray<{
+        readonly path: string;
+        readonly at: number;
+    }>;
+}
+/** An in-memory StorageLike for tests and for browsers without storage. */
+export declare function createMemoryStorage(): StorageLike;
+/** The browser's localStorage when reachable, else null (memory fallback). */
+export declare function browserStorage(): StorageLike | null;
+/**
+ * Create the reading record store over one storage backend.
+ * @param storage - the persistence face; every failing call degrades the
+ *   store to its in-memory copy for the rest of the session.
+ */
+export declare function createReadingStore(storage: StorageLike): ReadingStore;
+/** Where a stored position wants to land in the current document. */
+export type RestoreTarget = {
+    readonly kind: 'section';
+    readonly index: number;
+    readonly offsetIntoSection: number;
+} | {
+    readonly kind: 'fraction';
+    readonly fraction: number;
+} | {
+    readonly kind: 'top';
+};
+/**
+ * Resolve the restore plan for a stored position against the fresh outline.
+ * The chain: the stored section by text and ordinal → the stored outline
+ * index while it stays inside the valid range → the scroll fraction → the
+ * top. Resolution never fails; the caller always gets a place to be.
+ */
+export declare function resolveRestoreTarget(position: ReadingPosition, outline: readonly OutlineEntry[]): RestoreTarget;
+/**
+ * Capture the view face's current reading position from the rendered DOM.
+ * Mirrors the outline tracker's geometry: the reading line sits `inset`
+ * below the container top, and heading offsets are document coordinates.
+ * @returns the position, or null when the container carries no layout.
+ */
+export declare function captureViewPosition(container: HTMLElement, outline: readonly OutlineEntry[], at: number): ReadingPosition | null;
+/**
+ * Apply one stored position to the rendered document: scroll once to the
+ * resolved target, degrading exactly as the resolution prescribes. The
+ * assignment is the whole effect — no smooth scrolling, no re-application.
+ * @returns whether a scroll was applied.
+ */
+export declare function applyReadingPosition(container: HTMLElement, outline: readonly OutlineEntry[], position: ReadingPosition): boolean;
+//# sourceMappingURL=reading.d.ts.map

package/lib/types/client/turn-files.d.ts

@@ -6,8 +6,55 @@
  */
 import type { TurnTailOwnerProps } from '@deepseek-ai/dsh-client-ui-chat/client';
 import type { TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
+/** Structural slice of the deliverables Turn data the readers consume. */
+interface DeliverablesData {
+    readonly produced: ReadonlyArray<{
+        readonly seq: number;
+        readonly path: string;
+    }>;
+}
+/** Structural slice of the ui-chat turn-tail Turn data (closing facts). */
+interface TurnTailData {
+    readonly seq: number;
+    readonly closing?: {
+        readonly finalNode: {
+            readonly seq: number;
+        };
+    } | null;
+}
+/** Any turn-shaped holder whose data store answers the two keys we read. */
+interface TurnDataHolder {
+    readonly data: {
+        get(key: 'deliverables'): DeliverablesData | undefined;
+    } & {
+        get(key: 'turn-tail'): TurnTailData | undefined;
+    };
+}
+/** Structural slice of a Chat snapshot: the timeline is all we read. */
+export interface TurnOutputsSnapshot {
+    readonly timeline: {
+        readonly turnOrder: readonly number[];
+        readonly turns: ReadonlyMap<number, TurnDataHolder & {
+            readonly status: string;
+        }>;
+    };
+}
 /** Produced paths of one closing Turn, first-seen order, seq-cutoff applied. */
 export declare function producedPaths(turn: TurnLocation, seq: number): readonly string[];
+/**
+ * The previewable documents the session's newest turn produced — the quick
+ * entry's source (#31). Only the newest turn in the timeline counts: an
+ * earlier turn's outputs are never passed off as current. A closed turn
+ * fences at its closing seq (the same boundary the chip row applies — the
+ * turn-tail data's closing final node seq, falling back to the turn-end
+ * seq); an open turn keeps its produced-so-far as live facts. Nothing is
+ * parsed out of conversation prose, and no turn facts are copied — this
+ * derives a view over the owning service's data on each call.
+ * @param snapshot - the chat snapshot (timeline slice suffices).
+ * @returns previewable produced paths, first-seen order; empty when the
+ *   newest turn produced nothing previewable (or no turns exist).
+ */
+export declare function latestTurnPreviewable(snapshot: TurnOutputsSnapshot): readonly string[];
 /** Matched value for the turn-tail chain entry. */
 export interface MdTurnFiles {
     /** Markdown documents this turn produced (open the preview panel). */
@@ -23,4 +70,5 @@ export interface MdTurnFiles {
  * @returns the split paths when the turn produced markdown, otherwise null.
  */
 export declare function selectMdTurnFiles(owner: TurnTailOwnerProps): MdTurnFiles | null;
+export {};
 //# sourceMappingURL=turn-files.d.ts.map

package/lib/types/client/use-panel-dock.d.ts

@@ -0,0 +1,8 @@
+import { type PanelDockBounds } from './panel-dock.ts';
+/** Bind the frame adapter to the shell contribution's lifetime and local viewing state. */
+export declare function usePanelDock(open: boolean, width: number, maximized: boolean): {
+    anchor: import("react").RefObject<HTMLSpanElement>;
+    bounds: PanelDockBounds | null;
+    container: HTMLElement | null;
+};
+//# sourceMappingURL=use-panel-dock.d.ts.map

package/lib/types/client/use-preview-session.d.ts

@@ -22,8 +22,6 @@ export interface PanelDocumentSession {
         reload(): void;
         retryRead(): void;
         requestClose(): void;
-        discard(): void;
-        keepEditing(): void;
     };
 }
 /**

package/lib/types/config.d.ts

@@ -9,6 +9,12 @@ export interface Config {
     /** Extensions (lowercased, dot-prefixed) eligible for preview (a superset
      * of the editable set — plain-text members render but never edit). */
     previewExtensions: string[];
+    /** Workspace search: most matches one answer returns (result bound). */
+    searchMaxResults: number;
+    /** Workspace search: most directories one answer walks (traversal bound). */
+    searchMaxDirectories: number;
+    /** Workspace search: parallel directory listings per traversal step. */
+    searchConcurrency: number;
 }
 /** Standard Schema twin of {@link Config}; defaults live here, not in code. */
 export declare const Config: z<Config>;

package/lib/types/constants.d.ts

@@ -5,4 +5,12 @@ export declare const DEFAULT_MAX_BYTES = 1048576;
 export declare const DEFAULT_ALLOWED_EXTENSIONS: readonly [".md", ".markdown"];
 /** The preview union: readable (and rendered) even though only markdown edits. */
 export declare const DEFAULT_PREVIEW_EXTENSIONS: readonly [".md", ".markdown", ".txt"];
+/** Default search result cap: far above real agent-workspace document counts
+ * (tens to low hundreds observed in DSH sessions) while bounding one answer. */
+export declare const DEFAULT_SEARCH_MAX_RESULTS = 200;
+/** Default search traversal cap in directories: bounded for any deployment
+ * workspace; a pathological tree reports `traversal-limit`, never hangs. */
+export declare const DEFAULT_SEARCH_MAX_DIRECTORIES = 2000;
+/** Default parallel `listDir` width for one search. */
+export declare const DEFAULT_SEARCH_CONCURRENCY = 8;
 //# sourceMappingURL=constants.d.ts.map

package/lib/types/index.d.ts

@@ -7,9 +7,9 @@ import type { Context } from '@deepseek-ai/cordis';
 import { type Config as ConfigType } from './config.ts';
 export { Config } from './config.ts';
 export type { Config as ConfigInterface } from './config.ts';
-export { DEFAULT_ALLOWED_EXTENSIONS, DEFAULT_MAX_BYTES, DEFAULT_PREVIEW_EXTENSIONS } from './constants.ts';
+export { DEFAULT_ALLOWED_EXTENSIONS, DEFAULT_MAX_BYTES, DEFAULT_PREVIEW_EXTENSIONS, DEFAULT_SEARCH_CONCURRENCY, DEFAULT_SEARCH_MAX_DIRECTORIES, DEFAULT_SEARCH_MAX_RESULTS, } from './constants.ts';
 export { isAllowedExtension, MdPreviewService } from './remote.ts';
-export type { MdPreviewFile, MdPreviewFailureCode, MdPreviewReadRequest } from './protocol.ts';
+export type { MdPreviewFile, MdPreviewFailureCode, MdPreviewReadRequest, MdPreviewSearchLimit, MdPreviewSearchMatch, MdPreviewSearchResult, } from './protocol.ts';
 export { MD_PREVIEW_FAILURE_CODES } from './protocol.ts';
 export declare const name = "md-preview";
 /** Host services the read authority depends on. */

package/lib/types/protocol.d.ts

@@ -32,6 +32,33 @@ export interface MdPreviewListResult {
     /** Directory entries, folders first then alphabetical. */
     readonly entries: readonly MdPreviewEntry[];
 }
+/** One workspace document search match: a previewable document's name and
+ * where it lives, nothing about its content. */
+export interface MdPreviewSearchMatch {
+    /** Entry basename as the fs layer reports it (what the query matched). */
+    readonly name: string;
+    /** Workspace-relative path of the document (the open handoff identity). */
+    readonly path: string;
+}
+/** Why a search stopped short of a complete answer. */
+export type MdPreviewSearchLimit = 
+/** One or more directories could not be listed (permissions, io). */
+'directory-failure'
+/** The traversal cap stopped the walk before the workspace was covered. */
+ | 'traversal-limit'
+/** The result cap truncated the match list. */
+ | 'result-limit';
+/** One workspace document search answer. */
+export interface MdPreviewSearchResult {
+    /** The query exactly as the caller sent it. */
+    readonly query: string;
+    /** Previewable documents whose names matched, sorted by path. */
+    readonly matches: readonly MdPreviewSearchMatch[];
+    /** Whether the whole workspace was walked without any bound or failure. */
+    readonly complete: boolean;
+    /** Why the answer stopped short; empty exactly when complete. */
+    readonly limits: readonly MdPreviewSearchLimit[];
+}
 /** Stable failure codes carried by `RemoteError` across the wire. */
 export declare const MD_PREVIEW_FAILURE_CODES: readonly ["md-preview/bad-request", "md-preview/unknown-session", "md-preview/no-workspace", "md-preview/unsupported-extension", "md-preview/forbidden", "md-preview/not-found", "md-preview/too-large", "md-preview/conflict", "md-preview/unavailable"];
 /** One stable MdPreview failure code. */

package/lib/types/remote.d.ts

@@ -8,7 +8,7 @@ import type { Context } from '@deepseek-ai/cordis';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { Config } from './config.ts';
-import type { MdPreviewFile, MdPreviewListResult, MdPreviewWriteResult } from './protocol.ts';
+import type { MdPreviewFile, MdPreviewListResult, MdPreviewSearchResult, MdPreviewWriteResult } from './protocol.ts';
 /** Whether a candidate extension passes the configured allowlist. */
 export declare function isAllowedExtension(path: string, allowedExtensions: readonly string[]): boolean;
 /**
@@ -60,6 +60,23 @@ export declare class MdPreviewService extends TypertRemoteService {
      * @throws RemoteError with a stable MdPreview failure code.
      */
     list(sessionId: SessionId, path: string, signal: AbortSignal): Promise<MdPreviewListResult>;
+    /**
+     * Search previewable documents by name across the whole session workspace,
+     * including directories the browser face never expanded. First-version
+     * semantics: case-insensitive substring match on the entry name. The walk
+     * stays inside the session authority (root resolve + containment, visited
+     * dedupe so links cannot loop it), never reads file bodies, and reports
+     * honestly whether the answer is complete — a permission failure, a
+     * traversal bound, or the result cap each mark it incomplete with the
+     * matching limit.
+     * @param sessionId - owning session; its header cwd roots the walk.
+     * @param query - raw search text; matched case-insensitively against names.
+     * @param signal - caller cancellation carried through every fs call.
+     * @returns the query, its matches with workspace-relative paths, and
+     *   whether the walk finished whole.
+     * @throws RemoteError with a stable MdPreview failure code.
+     */
+    search(sessionId: SessionId, query: string, signal: AbortSignal): Promise<MdPreviewSearchResult>;
     /**
      * The shared authority preamble of the remote methods: resolve a path to a
      * live, contained, regular workspace file, or reject it with the stable

package/lib/types/typert/remote-client.d.ts

@@ -1,6 +1,6 @@
 import type { RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
-import type { MdPreviewFile, MdPreviewListResult, MdPreviewWriteResult } from '../protocol.ts';
+import type { MdPreviewFile, MdPreviewListResult, MdPreviewSearchResult, MdPreviewWriteResult } from '../protocol.ts';
 /** Browser face of the mounted `mdPreview` Remote namespace. */
 export interface MdPreviewRemote {
     /** Read one previewable document of a session's workspace. */
@@ -13,6 +13,8 @@ export interface MdPreviewRemote {
     write(sessionId: SessionId, path: string, content: string, fingerprint?: string, force?: boolean, signal?: AbortSignal): Promise<RemoteResult<MdPreviewWriteResult>>;
     /** List one workspace directory for the browser face (blank path = root). */
     list(sessionId: SessionId, path: string, signal?: AbortSignal): Promise<RemoteResult<MdPreviewListResult>>;
+    /** Search previewable document names over the whole session workspace. */
+    search(sessionId: SessionId, query: string, signal?: AbortSignal): Promise<RemoteResult<MdPreviewSearchResult>>;
 }
 declare module '@deepseek-ai/dsh-typert-protocol' {
     interface TypertRemoteNamespaceMap {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benz-ai-x/dsh-md-preview",
-  "version": "0.7.2",
+  "version": "0.10.0",
   "description": "DSH markdown preview: clicking a markdown document in the conversation opens a rendered preview panel docked to the right of the chat.",
   "license": "MIT",
   "repository": {

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

@@ -1,31 +0,0 @@
-/**
- * The header file-manager action: a collapse/expand button in the
- * conversation header that opens a workspace file-tree popover. Opening a
- * file hands it to the right preview panel; the popover stays open for
- * further picks. jsdom coverage asserts content and behavior, not layout
- * (no layout engine there).
- */
-import { type ReactElement } from 'react';
-import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
-import type { SessionId } from '@deepseek-ai/dsh-session/types';
-import type { MdPreviewListResult } from '../protocol.ts';
-import type { MdPreviewState } from './preview-state.ts';
-/** The composed props of the header action: slot kit + inject face + locale. */
-export type FileManagerActionProps = PropsRuntime<'conversation.session.header.actions'> & InjectFace<{
-    hooks: {
-        previewTarget: SnapshotStore<MdPreviewState>;
-    };
-    list(sessionId: SessionId, path: string, signal: AbortSignal): Promise<import('@deepseek-ai/dsh-typert-protocol').RemoteResult<MdPreviewListResult>>;
-    setTarget(target: {
-        sessionId: SessionId;
-        path: string;
-    } | null): void;
-}> & PropsLocale<'md-preview'>;
-/**
- * Render the header file-manager button and its popover for one session.
- * @param props - the composed action props.
- * @returns the trigger button (popover renders beside it in the panel tree).
- */
-export declare function FileManagerAction(props: FileManagerActionProps): ReactElement;
-//# sourceMappingURL=FileManagerAction.d.ts.map

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

@@ -1,43 +0,0 @@
-/**
- * The left-edge document browser: a collapse-style strip hugging the
- * conversation's left boundary (the app sidebar's right edge) that expands
- * into the session workspace tree. Opening a file hands it to the right
- * preview panel — left browser picks, right panel reads. The strip is
- * driven by a session probe: a null-rendering composer-dock entry that
- * publishes which conversation is showing.
- */
-import { type ReactElement } from 'react';
-import type { SessionId } from '@deepseek-ai/dsh-session/types';
-import type { MdPreviewListResult } from '../protocol.ts';
-/**
- * Publishes one conversation's session while that conversation shows.
- * Renders nothing; the activate/deactivate pair comes from the slot's
- * session-scoped inject closure.
- */
-export declare function SessionProbe(props: {
-    activate(): void;
-    deactivate(): void;
-}): null;
-/** The composed props of the side browser entry: stores + RPC + locale. */
-export interface SideBrowserProps {
-    /** Selector hook over the conversation probe's session (null without one). */
-    useCurrentSession(selector: (state: unknown) => unknown): unknown;
-    /** Selector hook over the preview target (for the current-file mark). */
-    usePreviewTarget(selector: (state: unknown) => unknown): unknown;
-    /** One directory listing; the transport carries the AbortSignal. */
-    list(sessionId: SessionId, path: string, signal: AbortSignal): Promise<import('@deepseek-ai/dsh-typert-protocol').RemoteResult<MdPreviewListResult>>;
-    /** Open one file in the right preview panel. */
-    setTarget(target: {
-        sessionId: SessionId;
-        path: string;
-    } | null): void;
-    /** Locale seat. */
-    t(key: string): string;
-}
-/**
- * Render the left-edge strip and, expanded, the workspace tree.
- * @param props - stores, listing RPC, panel handoff, locale seat.
- * @returns the side browser, or null while no conversation shows.
- */
-export declare function SideBrowser({ useCurrentSession, usePreviewTarget, list, setTarget, t }: SideBrowserProps): ReactElement | null;
-//# sourceMappingURL=SideBrowser.d.ts.map

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

@@ -1,40 +0,0 @@
-/**
- * The composer-dock entry: opens the preview panel on the session's
- * workspace without waiting for a turn that produced markdown — the dock
- * button lists the root, picks its first previewable file, and sets the
- * preview target; an empty root shows a transient hint instead.
- */
-import { type ReactElement } from 'react';
-import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { MdPreviewEntry } from '../protocol.ts';
-/**
- * The first previewable file of a root listing.
- * @param entries - one directory level, in listing order.
- * @returns its workspace-relative path, or null when nothing previews.
- */
-export declare function firstPreviewablePath(entries: readonly MdPreviewEntry[]): string | null;
-/** Props: the mount-bound open action plus the dock's locale seat. */
-export interface WorkspaceDocsDockProps {
-    /** Lists the workspace root and opens the first previewable file.
-     * Resolves 'none' when the root has nothing previewable. */
-    openWorkspace: () => Promise<'opened' | 'none'>;
-    /** Locale seat. */
-    t(key: string): string;
-}
-/** The registered header action: session slot kit + injected face + locale. */
-export type WorkspaceDocsDockActionProps = PropsRuntime<'conversation.session.header.actions'> & InjectFace<{
-    openWorkspace: () => Promise<'opened' | 'none'>;
-}> & PropsLocale<'md-preview'>;
-/**
- * Bind the slot's injected face into the presentational entry.
- * @param props - the header action's composed props.
- * @returns the header entry element.
- */
-export declare function WorkspaceDocsDockAction(props: WorkspaceDocsDockActionProps): ReactElement;
-/**
- * Render the dock entry for one session's workspace.
- * @param props - the bound open action and locale seat.
- * @returns the entry button (or its transient empty hint).
- */
-export declare function WorkspaceDocsDock({ openWorkspace, t }: WorkspaceDocsDockProps): import("react").JSX.Element;
-//# sourceMappingURL=WorkspaceDocsDock.d.ts.map

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

@@ -1,29 +0,0 @@
-/**
- * The 文档 conversation view: the session workspace tree rendered inside
- * the conversation area as a view tab (beside 对话/轨迹). Opening a file
- * sets the preview target — the docked panel takes it from there.
- */
-import type { ReactElement } from 'react';
-import type { ConvViewProps } from '@deepseek-ai/dsh-client-ui-conversation/client';
-import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
-import type { MdPreviewState } from './preview-state.ts';
-import type { MdPreviewListResult } from '../protocol.ts';
-/** The composed props of the docs view tab: session kit + inject face + locale. */
-export type WorkspaceDocsViewProps = ConvViewProps & InjectFace<{
-    hooks: {
-        previewTarget: SnapshotStore<MdPreviewState>;
-    };
-    list(sessionId: string, path: string, signal: AbortSignal): Promise<import('@deepseek-ai/dsh-typert-protocol').RemoteResult<MdPreviewListResult>>;
-    setTarget(target: {
-        sessionId: string;
-        path: string;
-    } | null): void;
-}> & PropsLocale<'md-preview'>;
-/**
- * Render the docs view tab body for one session.
- * @param props - the view's composed props.
- * @returns the workspace tree element.
- */
-export declare function WorkspaceDocsView({ sessionId, usePreviewTarget, list, setTarget, t }: WorkspaceDocsViewProps): ReactElement;
-//# sourceMappingURL=WorkspaceDocsView.d.ts.map