@deepseek-ai/dsh-client-ui-sidebar-documentpreview 0.1.5-alpha.2

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Pure host half; the whole preview lives in the browser export. */
+/** Host plugin body: the preview contributes nothing to the host tree. */
+function apply() {}
+//#endregion
+export { apply };

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

@@ -0,0 +1,8 @@
+/** Shared indeterminate loading feedback for document reads and rendering. */
+import type { ReactNode } from 'react';
+/** @param props - localized status label and optional placement style. @returns an animated, accessible loading status. */
+export declare function LoadingIndicator({ label, className }: {
+    label: string;
+    className?: string | undefined;
+}): ReactNode;
+//# sourceMappingURL=LoadingIndicator.d.ts.map

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

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
+import type { TextInjected } from './face.ts';
+import type { TextStore } from './store.ts';
+import type { DocumentPreviewDefinition } from './document/registry.ts';
+export { linesOf, loadedPages, lastLineLoaded, scrollToLine } from './text/lines.ts';
+export type { LoadedPage } from './text/lines.ts';
+/** Private registration inputs; the framework binds the registry source to useDocumentPreviews. */
+export interface TextPreviewInjected extends TextInjected {
+    readonly hooks: {
+        readonly documentPreviews: ObservableSnapshot<readonly DocumentPreviewDefinition[]>;
+    };
+}
+/** The body's composed props: the tab, its navigation, the shared store and face, and copy. */
+export type TextPreviewProps = PropsRuntime<'sidebar.right.pane.tab'> & PropsRenderSlots<'sidebar.right.tab.document'> & PropsStore<TextStore> & InjectFace<TextPreviewInjected> & PropsLocale<'sidebarDocumentPreview'>;
+/**
+ * The text type's body, registered under `sidebar.right.pane.tab` as `text`.
+ * @param props - composed slot props.
+ * @returns the content read so far with its controls, or a progress line.
+ */
+export declare function TextPreview({ useTabInfo, useResource, useStore, actions, loadPage, reloadPages, loadAll, reloadAll, useDocumentPreviews, renderSlot, t, }: TextPreviewProps): ReactNode;
+//# sourceMappingURL=TextPreview.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * The text type's chip title: the file type's coloured sheet before the name
+ * the registry captured at open time. Registered under
+ * `sidebar.right.pane.tab.title`; without it the chip would show the bare name.
+ */
+import type { ReactNode } from 'react';
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+/**
+ * The title as the chip and a floating panel's header show it.
+ * @param props - the tab information hook.
+ * @returns the type's 16px sheet followed by the tab's title text.
+ */
+export declare function TextTitle({ useTabInfo }: PropsRuntime<'sidebar.right.pane.tab.title'>): ReactNode;
+//# sourceMappingURL=TextTitle.d.ts.map

package/lib/types/client/code/CodeBody.d.ts

@@ -0,0 +1,9 @@
+/** Incrementally highlighted source; the document owner supplies the accumulated text and wrap preference. */
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { DocumentPreviewProps } from '../document/contract.ts';
+/** Document owner props and this renderer's localized controls. */
+export type CodeBodyProps = DocumentPreviewProps & PropsLocale<'sidebarCodePreview'>;
+/** @param props - accumulated document contents and framework props. @returns one stable CodeBlock, or no body for byte contents. */
+export declare function CodeBody({ resourceAddress, content, wrap, t }: CodeBodyProps): ReactNode;
+//# sourceMappingURL=CodeBody.d.ts.map

package/lib/types/client/code/index.d.ts

@@ -0,0 +1,5 @@
+/** Code preview metadata and body registered through the public document extension points. */
+import type { Context } from '@deepseek-ai/cordis';
+/** @param ctx - owning plugin context. Register localized metadata and the matching keyed document body. */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/code/languages.d.ts

@@ -0,0 +1,9 @@
+/** Recognized suffixes shared by renderer selection and language hints. */
+export declare const CODE_EXTENSIONS: readonly string[];
+/**
+ * Select the shared highlighter's grammar for a filename.
+ * @param path - decoded source filename or path.
+ * @returns a supported grammar hint, or undefined for other suffixes.
+ */
+export declare function languageForPath(path: string): string | undefined;
+//# sourceMappingURL=languages.d.ts.map

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

@@ -0,0 +1,19 @@
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Code document implementation name and copy controls. */
+        sidebarCodePreview: keyof typeof zh;
+    }
+}
+/** Simplified Chinese dictionary and key source. */
+export declare const zh: {
+    title: string;
+    copy: string;
+    copied: string;
+};
+/** English dictionary with the same keys. */
+export declare const en: {
+    title: string;
+    copy: string;
+    copied: string;
+};
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1,32 @@
+/**
+ * Stage one of this package's registration: what the `text` tab type IS.
+ *
+ * The type claims every `dsh-resource://file/session/<sessionId>/<path>`
+ * address at the `fallback` band: it
+ * is the plain viewer that any more specific type for the same address should
+ * beat, the position VS Code's text editor holds among its editors. `canOpen`
+ * refuses an address `parseFileAddress` rejects or that has no Session at claim time, where an
+ * unclaimed address is the documented wiring error.
+ */
+import type { SidebarRightTabDefinition } from '@deepseek-ai/dsh-client-ui-sidebar-right/client';
+/** The tab kind this package owns. */
+export declare const TEXTPREVIEW_KIND = "text";
+/** This implementation's identity in the tab system: the key its body registers under. */
+export declare const TEXTPREVIEW_ID = "@deepseek-ai/dsh-client-ui-sidebar-documentpreview";
+/**
+ * The tab title for one `file:` address: its decoded basename.
+ *
+ * The whole address stays the content identity, so two files with one name in
+ * different directories are two tabs; only the chip text is shortened. Decoding
+ * is per segment, matching how the address was built, so a name carrying `#`,
+ * `?`, or a space reads as itself.
+ * @param address - a `file:`-shaped address.
+ * @returns the decoded last path segment, or the address itself when it has none.
+ */
+export declare function basenameOf(address: string): string;
+/**
+ * The text type's registry definition.
+ * @returns the definition to register.
+ */
+export declare function textDefinition(): SidebarRightTabDefinition;
+//# sourceMappingURL=definition.d.ts.map

package/lib/types/client/document/contract.d.ts

@@ -0,0 +1,55 @@
+/** Document renderer slot: the owner supplies shared file state, renderers own their presentation. */
+import type { PropsRuntime, SlotHookFactory } from '@deepseek-ai/dsh-client-ui-slots';
+import type { UseSidebarRightTabInfo } from '@deepseek-ai/dsh-client-ui-sidebar-right/client';
+/** One loaded text window, retaining source line positions. */
+export interface DocumentTextPage {
+    readonly offset: number;
+    readonly text: string;
+    readonly lines: number;
+}
+/**
+ * Contents prepared by the preview owner using ordinary file reads.
+ * Byte arrays are transient UI input, never persisted layout or Session data.
+ */
+export type DocumentContent = {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly pages: readonly DocumentTextPage[];
+    readonly eof: boolean;
+} | {
+    readonly kind: 'bytes';
+    readonly data: Uint8Array<ArrayBuffer>;
+};
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface SlotMap {
+        /** Document body selected by a registered implementation id. */
+        'sidebar.right.tab.document': {
+            kind: 'keyed';
+            scope: 'session';
+            owner: {
+                /** Original file address, also readable through the standard useResource hook. */
+                readonly resourceAddress: string;
+                /** Loaded content; text is an accumulated prefix until eof. */
+                readonly content: DocumentContent;
+                /** The document toolbar's current wrapping preference. */
+                readonly wrap: boolean;
+            };
+            hookContext: UseSidebarRightTabInfo;
+            inject: {
+                hooks: {
+                    tabInfo: SlotHookFactory<'sidebar.right.tab.document', UseSidebarRightTabInfo>;
+                };
+            };
+        };
+    }
+}
+/** Standard input for every document body; entry-local stores and locale props can be intersected with it. */
+export type DocumentPreviewProps = PropsRuntime<'sidebar.right.tab.document'>;
+/**
+ * Forward the framework's tab reader to the selected document body.
+ * @param _standard - framework standard props.
+ * @param useTabInfo - enclosing tab's bound reader.
+ * @returns the same reader, without another subscription adapter.
+ */
+export declare const documentTabInfoFactory: SlotHookFactory<'sidebar.right.tab.document', UseSidebarRightTabInfo>;
+//# sourceMappingURL=contract.d.ts.map

package/lib/types/client/document/registry.d.ts

@@ -0,0 +1,55 @@
+/** How the document owner delivers file contents to a renderer. */
+export type DocumentLoadMode = 'text-pages' | 'bytes-complete';
+/** One renderer implementation, independent of its component registration. */
+export interface DocumentPreviewDefinition {
+    /** Unique implementation name, also used as the document slot key. */
+    readonly id: string;
+    /** File suffixes without a leading dot; compound suffixes such as tar.gz are accepted. */
+    readonly extensions: readonly string[];
+    /** External implementations win over product implementations; defaults to extension. */
+    readonly priority?: 'builtin' | 'extension';
+    /** Localized implementation label, evaluated when the toolbar renders. @returns the visible name. */
+    readonly title: () => string;
+    /** Content delivery mode supplied by the document owner. */
+    readonly loading: DocumentLoadMode;
+    /** Whether the implementation consumes the document's wrap preference. */
+    readonly wrap?: boolean;
+}
+/**
+ * Rank an observed definition snapshot without consulting mutable service state.
+ * @param definitions - registered implementations in registration order.
+ * @param path - decoded filename or file path.
+ * @returns matching implementations, external band first, then longest suffix.
+ */
+export declare function matchingDocumentPreviews(definitions: readonly DocumentPreviewDefinition[], path: string): readonly DocumentPreviewDefinition[];
+/** Observable registry of all live implementations, including lower-priority alternatives. */
+export declare class DocumentPreviewRegistry {
+    private readonly registered;
+    private readonly listeners;
+    private snapshot;
+    /**
+     * Read the current registrations.
+     * @returns the same snapshot until a registration changes.
+     */
+    readonly getSnapshot: () => readonly DocumentPreviewDefinition[];
+    /**
+     * Observe registration changes.
+     * @param listener - registration-change observer.
+     * @returns its disposer.
+     */
+    readonly subscribe: (listener: () => void) => (() => void);
+    /**
+     * Register metadata separately from the matching keyed slot component.
+     * @param definition - unique implementation and recognized suffixes.
+     * @returns an idempotent disposer; duplicate live implementation names throw.
+     */
+    register(definition: DocumentPreviewDefinition): () => void;
+    /**
+     * List every matching implementation in automatic-selection order.
+     * @param path - decoded file path; matching never resolves filesystem access.
+     * @returns extension band first, then longest suffix, then registration order.
+     */
+    candidates(path: string): readonly DocumentPreviewDefinition[];
+    private publish;
+}
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1,72 @@
+/**
+ * The preview's asynchronous half: reading pages into the store.
+ *
+ * The component never awaits anything. It asks for a page and this face performs
+ * the read and writes the outcome through the store's own actions — the
+ * Slot-standard `inject` form, so the write set stays the store's. The session
+ * the read runs under comes from the file's address, not from the slot's
+ * session: the address is the read's whole authority.
+ *
+ * A tab's pages are one file version walked from the first line. Dropping them
+ * — a reload, or a page of a newer version arriving past the first line, which
+ * restarts the walk — retires every read still in flight for the tab: a
+ * settlement from before the drop writes nothing. Cleanup rides the owner's
+ * `signal`, armed once per tab by its first read: the abort forgets the tab's
+ * bucket and this bookkeeping, a request is not made for a record that already
+ * ended, and a settlement arriving after the record is gone has nothing left to
+ * write to. A tab that never read has no bucket to forget.
+ */
+import type { BoundActions } from '@deepseek-ai/dsh-client-store';
+import type { TabId } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { ReadDocumentBytes, ReadWorkspaceFilePage, SessionFile } from './rpc.ts';
+import type { TextStore } from './store.ts';
+/** The preview's injected business face, as the body receives it. */
+export interface TextInjected {
+    /**
+     * Read one page into the store. A page of a newer file version than the pages
+     * held, arriving past the first line, is not kept: the tab's pages are dropped
+     * and the first page read again. The tab's first read arms the abort listener
+     * that forgets its bucket when the record ends.
+     * @param tabId - the tab being drawn.
+     * @param file - the session and workspace path the tab's address names.
+     * @param offset - 1-based line the page starts at.
+     * @param signal - the tab record's lifetime.
+     * @param observedVersion - metadata version observed at read start.
+     */
+    readonly loadPage: (tabId: TabId, file: SessionFile, offset: number, signal: AbortSignal, observedVersion?: string) => void;
+    /**
+     * Drop every page and read the first one again, for a file the Host reports
+     * changed. The view is kept, so the reader stays where they were; a page read
+     * still in flight writes nothing when it settles.
+     * @param tabId - the tab being drawn.
+     * @param file - the session and workspace path the tab's address names.
+     * @param signal - the tab record's lifetime.
+     * @param observedVersion - metadata version observed at read start.
+     */
+    readonly reloadPages: (tabId: TabId, file: SessionFile, signal: AbortSignal, observedVersion?: string) => void;
+    /**
+     * Read the complete file for a whole-file renderer.
+     * @param tabId - owning tab.
+     * @param file - the session and workspace path the tab's address names.
+     * @param signal - tab lifetime.
+     * @param observedVersion - metadata version observed at read start.
+     */
+    readonly loadAll: (tabId: TabId, file: SessionFile, signal: AbortSignal, observedVersion?: string) => void;
+    /**
+     * Discard the old complete result and read again.
+     * @param tabId - owning tab.
+     * @param file - the session and workspace path the tab's address names.
+     * @param signal - tab lifetime.
+     * @param observedVersion - metadata version observed at read start.
+     */
+    readonly reloadAll: (tabId: TabId, file: SessionFile, signal: AbortSignal, observedVersion?: string) => void;
+}
+/**
+ * Bind the preview's face to one paged read and one complete-byte read.
+ * @param read - the bound `workspaceFiles.read` call.
+ * @param readAll - ordinary complete-byte Remote read.
+ * @returns the Slot `inject` factory: bound actions in, face out. The slot's session id is unused because the address carries its own.
+ */
+export declare function textFace(read: ReadWorkspaceFilePage, readAll: ReadDocumentBytes): (sessionId: SessionId, actions: BoundActions<TextStore>) => TextInjected;
+//# sourceMappingURL=face.d.ts.map

package/lib/types/client/failure-line.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The failure line one Remote code deserves.
+ *
+ * Kept apart from the component so the mapping is testable on its own. Codes
+ * this reader does not name fall to the generic line carrying the carrier's
+ * message.
+ */
+import type { RemoteFailure } from '@deepseek-ai/dsh-api-remotes/client';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-locale/client';
+/**
+ * Say what went wrong, in terms of the file rather than of the transport.
+ * @param t - namespace-bound translate.
+ * @param failure - the settled Remote failure.
+ * @returns the line to show in place of the file.
+ */
+export declare function failureLine(t: TranslateNS<'sidebarDocumentPreview'>, failure: RemoteFailure): string;
+//# sourceMappingURL=failure-line.d.ts.map

package/lib/types/client/html/HtmlBody.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { DocumentPreviewProps } from '../document/contract.ts';
+import type { ReadHtmlRelated } from './read-relative.ts';
+/** Standard document inputs plus this renderer's dictionary. */
+export type HtmlBodyProps = DocumentPreviewProps & PropsLocale<'documentHtml'> & {
+    /** Ordinary Remote callback bound by this renderer's Slot inject. */
+    readonly readRelated: ReadHtmlRelated;
+};
+/**
+ * Render complete HTML with the standard file and tab hooks.
+ * @param props - document bytes, hooks, related-file reader and locale.
+ * @returns an isolated HTML document, or nothing for text delivery.
+ */
+export declare function HtmlBody({ content, resourceAddress, readRelated, useTabInfo, t }: HtmlBodyProps): ReactNode;
+//# sourceMappingURL=HtmlBody.d.ts.map

package/lib/types/client/html/bootstrap.d.ts

@@ -0,0 +1,20 @@
+/** One statically declared local script or stylesheet, already read under the source file's authority. */
+export interface HtmlAsset {
+    readonly kind: 'script' | 'stylesheet';
+    /** Original HTML attribute, not a Host absolute path. */
+    readonly reference: string;
+    readonly data: Uint8Array<ArrayBuffer>;
+}
+/** Complete bytes for one document; dependencies are finite and never requested by iframe messages. */
+export interface HtmlBundle {
+    readonly data: Uint8Array<ArrayBuffer>;
+    readonly assets: readonly HtmlAsset[];
+}
+/**
+ * Build the outer iframe document. Its resource URLs are created inside the sandbox,
+ * because that opaque origin cannot load resource URLs created by the parent.
+ * @param bundle - complete HTML bytes and optional static dependencies.
+ * @returns bootstrap HTML; invalid UTF-8 throws before navigation.
+ */
+export declare function createHtmlDocument(bundle: HtmlBundle): string;
+//# sourceMappingURL=bootstrap.d.ts.map

package/lib/types/client/html/bytes.d.ts

@@ -0,0 +1,14 @@
+/** UTF-8 decoding for file bytes and encoding only for the iframe's script payload. */
+/**
+ * Decode complete UTF-8 text, rejecting invalid byte sequences.
+ * @param data - complete UTF-8 bytes.
+ * @returns decoded text; invalid UTF-8 throws.
+ */
+export declare function decodeText(data: Uint8Array<ArrayBuffer>): string;
+/**
+ * Encode Unicode text for the iframe's base64 payload.
+ * @param text - Unicode text.
+ * @returns base64 of its UTF-8 bytes.
+ */
+export declare function encodeText(text: string): string;
+//# sourceMappingURL=bytes.d.ts.map

package/lib/types/client/html/index.d.ts

@@ -0,0 +1,17 @@
+/** Builtin HTML metadata and keyed body registration; assembly belongs to the package entry. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { DocumentPreviewDefinition } from '../document/registry.ts';
+/** HTML implementation identity, shared by metadata and the keyed slot. */
+export declare const HTML_BODY_ID = "@deepseek-ai/dsh-client-ui-sidebar-documentpreview/html";
+/**
+ * Describe the builtin HTML renderer's file types and loading mode.
+ * @param title - locale-owned implementation name.
+ * @returns metadata for complete HTML documents.
+ */
+export declare function htmlBodyDefinition(title: () => string): DocumentPreviewDefinition;
+/**
+ * Register the HTML dictionary, metadata and body with reversible effects.
+ * @param ctx - owning plugin context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,23 @@
+/** Locale-owned HTML implementation name and iframe status text. */
+export declare const zh: {
+    title: string;
+    frame: string;
+    loading: string;
+    failed: string;
+};
+/** HTML renderer dictionary keys. */
+export type HtmlPreviewKey = keyof typeof zh;
+/** English dictionary with the same keys as the Chinese dictionary. */
+export declare const en: {
+    title: string;
+    frame: string;
+    loading: string;
+    failed: string;
+};
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** HTML preview selection and status text. */
+        documentHtml: HtmlPreviewKey;
+    }
+}
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/html/pack.d.ts

@@ -0,0 +1,21 @@
+/** Finite HTML-declared classic scripts and stylesheets; no module, CSS dependency or runtime fetch traversal. */
+import type { HtmlBundle } from './bootstrap.ts';
+import type { DocumentFileBytes } from '../rpc.ts';
+/**
+ * A read bound to the original document's session and directory, using ordinary file operations.
+ * @param reference - HTML-decoded relative URL, including any query or fragment; the reader resolves its file path.
+ * @param signal - cancellation of this packing operation.
+ * @returns complete file bytes; permission and read failures reject.
+ */
+export type ReadHtmlRelative = (reference: string, signal: AbortSignal) => Promise<DocumentFileBytes>;
+/**
+ * Collect static dependencies without executing or mounting document elements in the parent page.
+ * A base element leaves URL resolution to the browser. Only direct .js classic scripts and .css
+ * links are packed; local CSS url/import, modules and dynamically constructed URLs are unsupported.
+ * @param data - complete UTF-8 HTML bytes.
+ * @param readRelative - original-document-scoped read, never exposed to the iframe.
+ * @param signal - stops reads and prevents publication after cancellation.
+ * @returns complete HTML and its finite static asset set; decoding, limits and read failures reject.
+ */
+export declare function packHtml(data: Uint8Array<ArrayBuffer>, readRelative: ReadHtmlRelative, signal: AbortSignal): Promise<HtmlBundle>;
+//# sourceMappingURL=pack.d.ts.map

package/lib/types/client/html/read-relative.d.ts

@@ -0,0 +1,21 @@
+/** Adapt a Remote relative read without changing its Session or Host path authority. */
+import type { RemoteResult } from '@deepseek-ai/dsh-api-remotes/client';
+import type { WorkspaceFileBytes } from '@deepseek-ai/dsh-api-workspace-files/types';
+import type { ReadHtmlRelative } from './pack.ts';
+/**
+ * Read one dependency relative to the addressed HTML file through the Host.
+ * @param address - root HTML file address.
+ * @param relativePath - decoded dependency path, resolved only by the Host.
+ * @param signal - cancellation shared by the tab and packing operation.
+ * @returns the Remote complete-byte result, including declared failures.
+ */
+export type ReadHtmlRelated = (address: string, relativePath: string, signal: AbortSignal) => Promise<RemoteResult<WorkspaceFileBytes>>;
+/**
+ * Bind a package reader to the original HTML file's address.
+ * @param readRelated - Remote reader using the Session in the root HTML address.
+ * @param address - root HTML file address.
+ * @param lifetime - tab lifetime.
+ * @returns a reader that strips URL query/fragment, decodes one path, and preserves Host failures.
+ */
+export declare function createReadHtmlRelative(readRelated: ReadHtmlRelated, address: string, lifetime: AbortSignal): ReadHtmlRelative;
+//# sourceMappingURL=read-relative.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * Glyphs this package draws that the shared icon set does not carry yet.
+ * Same props contract as `@deepseek-ai/dsh-client-ui-primitives` icons, so a
+ * shared replacement is a one-line import change.
+ *
+ * The wrap control swaps between the two glyphs below to preview the mode a
+ * click switches to, so neither needs a pressed style.
+ */
+import type { IconProps } from '@deepseek-ai/dsh-client-ui-primitives';
+/** Two margin bars, a straight arrow running to the right one: lines run past the edge. */
+export declare const IconNowrapFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Two margin bars, an arrow sweeping around and back left: lines turn under themselves. */
+export declare const IconWrapFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=icons.d.ts.map

package/lib/types/client/image/ImageBody.d.ts

@@ -0,0 +1,31 @@
+/** Complete image bytes rendered at their intrinsic CSS-pixel dimensions. */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { DocumentPreviewProps } from '../document/contract.ts';
+declare const IMAGE_MEDIA_TYPES: {
+    readonly png: "image/png";
+    readonly jpg: "image/jpeg";
+    readonly jpeg: "image/jpeg";
+    readonly gif: "image/gif";
+    readonly webp: "image/webp";
+    readonly bmp: "image/bmp";
+    readonly ico: "image/x-icon";
+    readonly svg: "image/svg+xml";
+};
+type ImageMediaType = typeof IMAGE_MEDIA_TYPES[keyof typeof IMAGE_MEDIA_TYPES];
+/** Standard document props plus the image renderer's dictionary. */
+export type ImageBodyProps = DocumentPreviewProps & PropsLocale<'sidebarImage'>;
+/**
+ * Resolve a supported filename to the media type assigned to its Blob.
+ * @param path - decoded workspace file path.
+ * @returns the image media type, or undefined for an unregistered suffix.
+ */
+export declare function imageMediaType(path: string): ImageMediaType | undefined;
+/**
+ * Present complete image bytes without fitting or scaling them to the pane.
+ * @param props - document bytes, resource identity, and locale.
+ * @returns an intrinsic-size image whose containing document body provides scrolling.
+ */
+export declare function ImageBody({ content, resourceAddress, t }: ImageBodyProps): ReactNode;
+export {};
+//# sourceMappingURL=ImageBody.d.ts.map

package/lib/types/client/image/index.d.ts

@@ -0,0 +1,19 @@
+/** Builtin image metadata and keyed document-body registration. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { DocumentPreviewDefinition } from '../document/registry.ts';
+/** Image implementation identity, shared by metadata and the keyed slot. */
+export declare const IMAGE_BODY_ID = "@deepseek-ai/dsh-client-ui-sidebar-documentpreview/image";
+/** File suffixes rendered by the builtin image body. */
+export declare const IMAGE_EXTENSIONS: readonly ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg"];
+/**
+ * Describe the builtin image renderer independently from its keyed body slot.
+ * @param title - locale-owned implementation name.
+ * @returns metadata for complete image files.
+ */
+export declare function imageBodyDefinition(title: () => string): DocumentPreviewDefinition;
+/**
+ * Register the image dictionary, metadata, and body with reversible effects.
+ * @param ctx - owning plugin context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,25 @@
+/** Locale-owned image renderer labels and status text. */
+export declare const zh: {
+    title: string;
+    preview: string;
+    loading: string;
+    failed: string;
+    unsupported: string;
+};
+/** Image renderer dictionary keys. */
+export type ImagePreviewKey = keyof typeof zh;
+/** English dictionary with the same keys as the Chinese dictionary. */
+export declare const en: {
+    title: string;
+    preview: string;
+    loading: string;
+    failed: string;
+    unsupported: string;
+};
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Image preview selection, accessible name, and status text. */
+        sidebarImage: ImagePreviewKey;
+    }
+}
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1,51 @@
+/**
+ * Browser half: register `text` as a right-Sidebar tab type.
+ *
+ * The type reaches the Sidebar through its public path only: the definition into
+ * `ctx.sidebarRightTabs`, the body into the keyed `sidebar.right.pane.tab`
+ * seat, and the chip title into `sidebar.right.pane.tab.title`, both under the
+ * definition's `id`. Nothing here reaches into the Sidebar's store, its
+ * panes, or its sequence. The file's metadata comes from the standard
+ * `useResource`, served by the `file` provider; the content is this type's own
+ * business, read through its face. Every import from another
+ * client plugin is a type.
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import type { WorkspaceFileParams } from '@deepseek-ai/dsh-api-workspace-files/client';
+import { DocumentPreviewRegistry } from './document/registry.ts';
+export type { SidebarDocumentPreviewKey } from './locales.ts';
+export type { TextPreviewProps } from './TextPreview.tsx';
+export type { TextInjected } from './face.ts';
+export type { ReadWorkspaceFilePage, SessionFile, WorkspaceFilesReadRemote } from './rpc.ts';
+export type { TextPage, TextState, TextStore, TextTabState } from './store.ts';
+export type { DocumentContent, DocumentPreviewProps, DocumentTextPage } from './document/contract.ts';
+export type { DocumentLoadMode, DocumentPreviewDefinition } from './document/registry.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** File-extension renderer registrations, independent from their keyed document bodies. */
+        documentPreviews: DocumentPreviewRegistry;
+    }
+}
+declare module '@deepseek-ai/dsh-client-ui-sidebar-right/client' {
+    interface SidebarRightResourceParamsMap {
+        /** File line navigation supported by the text preview. */
+        file: WorkspaceFileParams;
+    }
+}
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Text-preview progress, paging, change, control, and failure lines. */
+        sidebarDocumentPreview: import('./locales.ts').SidebarDocumentPreviewKey;
+    }
+}
+/**
+ * Required browser services: the tab registry, the slot registry, copy, and the
+ * Remote carrier with its `workspaceFiles` namespace.
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the type, its dictionaries, its body, and its chip title.
+ * @param ctx - client root context carrying the registry, the slots, copy, and the Remote face.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map