@qilin-agent/client-ui-sidebar-documentpreview 0.0.0-stage → 3.1.3

package/lib/types/client/excel/xlsx-archive.d.ts

@@ -0,0 +1,21 @@
+/** Owns the unpacked preview copy and its detected unsupported content. */
+export declare class XlsxPreviewArchive {
+    private readonly bytes;
+    /** Detected workbook content that the preview does not display. */
+    readonly unsupportedFeatures: Set<"charts" | "images" | "shapes" | "conditionalFormatting">;
+    private readonly files;
+    private readonly parts;
+    /**
+     * Read an archive without modifying the borrowed source buffer.
+     * @param bytes - Complete XLSX source bytes.
+     * @throws When ZIP entries have ASCII case-equivalent names.
+     */
+    constructor(bytes: Uint8Array<ArrayBuffer>);
+    /**
+     * Omit DrawingML parts before ExcelJS parses them; callers must also ignore worksheet drawing references.
+     * @returns Source bytes when no parts were omitted, otherwise an uncompressed temporary ZIP.
+     */
+    withoutDrawings(): Uint8Array<ArrayBuffer>;
+    private inspectContent;
+}
+//# sourceMappingURL=xlsx-archive.d.ts.map

package/lib/types/client/excel/xlsx.d.ts

@@ -0,0 +1,9 @@
+import { type ExcelLimits, type ExcelPreview } from './model.ts';
+/**
+ * Decode an XLSX into display cells, omitting drawings and retaining formulas without recalculation.
+ * @param bytes - Complete borrowed workbook bytes.
+ * @param limits - File and matrix allocation limits.
+ * @returns Sheets ready for a read-only FortuneSheet workbook.
+ */
+export declare function convertXlsx(bytes: Uint8Array<ArrayBuffer>, limits: ExcelLimits): Promise<ExcelPreview>;
+//# sourceMappingURL=xlsx.d.ts.map

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

@@ -0,0 +1,87 @@
+/**
+ * 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 '@qilin-agent/client-store';
+import type { TabId } from '@qilin-agent/client-ui-dockkit';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { ReadDocumentBytes, ReadWorkspaceFilePage, SessionFile } from './rpc.ts';
+import type { TextStore } from './store.ts';
+import type { Resources } from '@qilin-agent/client-resources/client';
+/** The preview's injected business face, as the body receives it. */
+export interface TextInjected {
+    /** Observe one renderer dependency. @param tabId - owning tab. @param address - resource address. @param signal - tab lifetime. */
+    readonly addResource: (tabId: TabId, address: string, signal: AbortSignal) => void;
+    /** Replace dependency membership. @param tabId - owning tab. @param addresses - resource addresses. @param signal - tab lifetime. */
+    readonly setResources: (tabId: TabId, addresses: readonly string[], signal: AbortSignal) => void;
+    /**
+     * 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;
+    /**
+     * Begin a renderer-owned load without reading source bytes.
+     * @param tabId - owning tab.
+     * @param signal - tab lifetime.
+     * @param rendererId - selected implementation.
+     * @param observedVersion - metadata version observed at request start.
+     * @param reload - discard the previous content revision.
+     */
+    readonly prepareRenderer: (tabId: TabId, signal: AbortSignal, rendererId: string, observedVersion?: string, reload?: boolean) => 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.
+ * @param resources - shared metadata sources for the document and its dependencies.
+ * @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, resources: Resources): (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 '@qilin-agent/api-remotes/client';
+import type { TranslateNS } from '@qilin-agent/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,22 @@
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale } from '@qilin-agent/client-ui-slots';
+import type { ObservableSnapshot } from '@qilin-agent/client-store';
+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'> & InjectFace<HtmlBodyInjected>;
+/** Related-file reader and accepted preview mode supplied by the plugin. */
+export interface HtmlBodyInjected {
+    hooks: {
+        interactivePreview: ObservableSnapshot<boolean>;
+    };
+    /** 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, useInteractivePreview, addResource, setResources, t, }: HtmlBodyProps): ReactNode;
+//# sourceMappingURL=HtmlBody.d.ts.map

package/lib/types/client/html/basic-document.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prepare static content before the browser can load any document resources.
+ * @param data - complete UTF-8 HTML bytes.
+ * @returns document with the restrictive CSP first in its head.
+ */
+export declare function createBasicHtmlDocument(data: Uint8Array<ArrayBuffer>): string;
+//# sourceMappingURL=basic-document.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 '@qilin-agent/kylin';
+import type { DocumentPreviewDefinition } from '../document/registry.ts';
+/** HTML implementation identity, shared by metadata and the keyed slot. */
+export declare const HTML_BODY_ID = "@qilin-agent/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 '@qilin-agent/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,22 @@
+/** Adapt a Remote relative read without changing its Session or Host path authority. */
+import type { RemoteResult } from '@qilin-agent/api-remotes/client';
+import type { WorkspaceFileBytes } from '@qilin-agent/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.
+ * @param addResource - subscribes to the dependency path reported by the Host.
+ * @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, addResource: (address: string) => void): 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 `@qilin-agent/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 '@qilin-agent/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,32 @@
+/** Complete image bytes rendered in a shared zoom viewport. */
+import { type ReactNode } from 'react';
+import type { PropsLocale, PropsStore } from '@qilin-agent/client-ui-slots';
+import type { DocumentPreviewProps } from '../document/contract.ts';
+import { type ZoomInjected, type ZoomStore } from '../zoom/store.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'> & PropsStore<ZoomStore> & ZoomInjected;
+/**
+ * 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 with fit-width and fixed-scale viewing.
+ * @param props - document bytes, resource identity, and locale.
+ * @returns a rounded image fitted or scaled at its intrinsic aspect ratio.
+ */
+export declare function ImageBody(props: ImageBodyProps): ReactNode;
+export {};
+//# sourceMappingURL=ImageBody.d.ts.map

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

@@ -0,0 +1,21 @@
+/** Builtin image metadata and keyed document-body registration. */
+import type { Context } from '@qilin-agent/kylin';
+import type { DocumentPreviewDefinition } from '../document/registry.ts';
+/** Image implementation identity, shared by metadata and the keyed slot. */
+export declare const IMAGE_BODY_ID = "@qilin-agent/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"];
+/** Bitmap suffixes whose bytes are unreadable as text; SVG stays out because its XML source is worth reading. */
+export declare const BINARY_IMAGE_EXTENSIONS: readonly ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico"];
+/**
+ * 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,37 @@
+/** Locale-owned image renderer labels and status text. */
+export declare const zh: {
+    title: string;
+    preview: string;
+    loading: string;
+    failed: string;
+    unsupported: string;
+    zoomControls: "缩放控件";
+    zoomMenu: "选择缩放比例";
+    zoomOut: "缩小";
+    zoomIn: "放大";
+    zoomFitWidth: "适应宽度";
+    zoomValue: "{percent}%";
+};
+/** 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;
+    zoomControls: string;
+    zoomMenu: string;
+    zoomOut: string;
+    zoomIn: string;
+    zoomFitWidth: string;
+    zoomValue: string;
+};
+declare module '@qilin-agent/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,53 @@
+/**
+ * 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 '@qilin-agent/kylin';
+import type { WorkspaceFileParams } from '@qilin-agent/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 { ReadDocumentBytes, DocumentFileBytes, 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 '@qilin-agent/kylin' {
+    interface Context {
+        /** File-extension renderer registrations, independent from their keyed document bodies. */
+        documentPreviews: DocumentPreviewRegistry;
+    }
+}
+declare module '@qilin-agent/client-ui-sidebar-right/client' {
+    interface SidebarRightResourceParamsMap {
+        /** File line navigation supported by the text preview. */
+        file: WorkspaceFileParams;
+    }
+}
+declare module '@qilin-agent/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, the
+ * shared resource model, the developer-tools preference that selects the HTML
+ * preview policy, the conversation assembly a viewer selection lands in, 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

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

@@ -0,0 +1,66 @@
+/**
+ * `sidebarDocumentPreview` namespace dictionaries.
+ *
+ * The failure lines are the point of this file: a preview that cannot show a
+ * page has to say which of several different things went wrong, and each one
+ * suggests a different next step for the reader.
+ */
+/** Simplified Chinese dictionary and key-set source of truth. */
+export declare const zh: {
+    loading: string;
+    loadMore: string;
+    changed: string;
+    reloadNow: string;
+    reload: string;
+    autoRefresh: string;
+    'autoRefresh.enable': string;
+    'autoRefresh.disable': string;
+    'wrap.enable': string;
+    'wrap.disable': string;
+    'wrap.aria': string;
+    openWith: string;
+    edit: string;
+    'type.label': string;
+    'viewer.text': string;
+    resourceUnavailable: string;
+    rendererUnavailable: string;
+    unsupportedFile: string;
+    'error.notFound': string;
+    'error.tooLarge': string;
+    'error.notText': string;
+    'error.notRegularFile': string;
+    'error.unavailable': string;
+    retry: string;
+    addToConversation: string;
+};
+/** Text-preview dictionary key union. */
+export type SidebarDocumentPreviewKey = keyof typeof zh;
+/** English dictionary, checked against the Chinese key set. */
+export declare const en: {
+    loading: string;
+    loadMore: string;
+    changed: string;
+    reloadNow: string;
+    reload: string;
+    autoRefresh: string;
+    'autoRefresh.enable': string;
+    'autoRefresh.disable': string;
+    'wrap.enable': string;
+    'wrap.disable': string;
+    'wrap.aria': string;
+    openWith: string;
+    edit: string;
+    'type.label': string;
+    'viewer.text': string;
+    resourceUnavailable: string;
+    rendererUnavailable: string;
+    unsupportedFile: string;
+    'error.notFound': string;
+    'error.tooLarge': string;
+    'error.notText': string;
+    'error.notRegularFile': string;
+    'error.unavailable': string;
+    retry: string;
+    addToConversation: string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/markdown/MarkdownBody.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@qilin-agent/client-ui-slots';
+import type { DocumentPreviewProps } from '../document/contract.ts';
+/** Standard document inputs and this implementation's locale. */
+export type MarkdownBodyProps = DocumentPreviewProps & PropsLocale<'documentMarkdown'>;
+/**
+ * Render one accumulated document; EOF completes the primitive's full parse.
+ * @param props - owner-loaded contents and localized primitive labels.
+ * @returns Markdown content, or nothing for a non-text delivery.
+ */
+export declare function MarkdownBody({ content, resourceAddress, useResource, t }: MarkdownBodyProps): ReactNode;
+//# sourceMappingURL=MarkdownBody.d.ts.map

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

@@ -0,0 +1,17 @@
+/** Builtin Markdown metadata and keyed document-body registration. */
+import type { Context } from '@qilin-agent/kylin';
+import type { DocumentPreviewDefinition } from '../document/registry.ts';
+/** Implementation identity shared by metadata and the document slot. */
+export declare const MARKDOWN_BODY_ID = "@qilin-agent/client-ui-sidebar-documentpreview/markdown";
+/**
+ * Describe the Markdown implementation without taking ownership of loading.
+ * @param title - locale-owned implementation name.
+ * @returns builtin Markdown registration metadata.
+ */
+export declare function markdownDefinition(title: () => string): DocumentPreviewDefinition;
+/**
+ * Register locale, metadata, and the document body for the owning plugin lifetime.
+ * @param ctx - plugin context carrying locale, document registry, and slots.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,27 @@
+/** Markdown implementation labels and primitive chrome. */
+export declare const zh: {
+    'viewer.label': string;
+    'code.copy': string;
+    'code.copied': string;
+    footnotes: string;
+    'mermaid.diagram': string;
+    'mermaid.enlarged': string;
+};
+/** Markdown namespace keys. */
+export type MarkdownPreviewKey = keyof typeof zh;
+/** English labels, paired with the Chinese key set. */
+export declare const en: {
+    'viewer.label': string;
+    'code.copy': string;
+    'code.copied': string;
+    footnotes: string;
+    'mermaid.diagram': string;
+    'mermaid.enlarged': string;
+};
+declare module '@qilin-agent/client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Markdown document renderer and its code/footnote controls. */
+        documentMarkdown: MarkdownPreviewKey;
+    }
+}
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/markdown/path-images.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Build a file URL, resolving relative destinations beside the previewed file.
+ * @param base - document base URI, including any deployment prefix.
+ * @param documentPath - absolute source path reported by the Host, when available.
+ * @param destination - authored Markdown image URL; query and fragment are not filename components.
+ * @returns a file URL, or undefined for unsupported or malformed destinations.
+ */
+export declare function markdownImageUrl(base: string, documentPath: string | undefined, destination: string): string | undefined;
+//# sourceMappingURL=path-images.d.ts.map

package/lib/types/client/markdown/sanitize-html.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Decide whether an HTML run opens with a block-level element.
+ *
+ * The markdown parse already places the run where it belongs; this only picks
+ * the wrapper, so a run that starts with a comment, a closing tag, or anything
+ * unrecognized stays phrasing-level.
+ * @param source - the authored HTML run.
+ * @returns whether the run opens with a block-level element.
+ */
+export declare function opensWithBlockTag(source: string): boolean;
+/**
+ * Decide whether a run may be rendered as sanitized HTML.
+ *
+ * Only a complete block qualifies. The parse hands one run per tag in phrasing
+ * context, so an inline `<sub>` arrives without the `</sub>` that closes it in
+ * the source — rendering it would drop the markup and keep the text, which is
+ * a silent change from showing the tag. A block opening without any closing tag
+ * (`<div class="note">` … Markdown … `</div>` across runs) would render as an
+ * empty element around nothing. Both stay literal; both are recorded in the
+ * package README.
+ * @param source - the authored HTML run.
+ * @returns whether the run is a complete block-level element.
+ */
+export declare function renderableMarkdownHtml(source: string): boolean;
+/**
+ * Sanitize one authored HTML run.
+ * @param source - the raw HTML the markdown stream carried.
+ * Only a run {@link renderableMarkdownHtml} accepts reaches this, so the
+ * markup is always rendered in a block wrapper.
+ * @param resolveMedia - rewrites one `src` destination, returning undefined when the destination is refused.
+ * @returns the sanitized markup; empty when nothing survived.
+ */
+export declare function sanitizeMarkdownHtml(source: string, resolveMedia: (destination: string) => string | undefined): string;
+//# sourceMappingURL=sanitize-html.d.ts.map

package/lib/types/client/media-url.d.ts

@@ -0,0 +1,15 @@
+/**
+ * URLs for the host preview-media route (`@qilin-agent/host-preview-media`): one
+ * session file over `/sidebar/media`, Range-streamable for the video viewer
+ * and switchable to a download disposition.
+ */
+/** Absolute-path URL of the media route for one session file.
+ * @param sessionId - Session whose workspace root resolves the path.
+ * @param path - absolute path or workspace-relative path.
+ * @param options - `download` switches the disposition to an attachment.
+ * @returns the relative `/sidebar/media` URL carrying the session and path.
+ */
+export declare function previewMediaUrl(sessionId: string, path: string, options?: {
+    readonly download?: boolean;
+}): string;
+//# sourceMappingURL=media-url.d.ts.map