dsh-coding-sidebar 1.0.0

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

@@ -0,0 +1,452 @@
+/**
+ * Minimal zh/en/ja copy for the sidebar. The copy follows the DSH i18n system:
+ * the client apply attaches the locale service (`ctx.locale`, provided by
+ * `@deepseek-ai/dsh-client-locale`) through {@link attachLocale}, and
+ * `t()`/`isZh()` resolve the active locale from it — the Host-backed
+ * `locale.preference` wins over the raw browser language and switches live.
+ * Without an attached service (standalone/test compositions) the browser
+ * language is used, matching the previous behavior. The dictionaries are
+ * also registered into the DSH locale registry under {@link LOCALE_NS}.
+ *
+ * ja (Japanese) is opt-in through `@huanlin/dsh-plugin-better-locale`: when
+ * that plugin is installed, the client apply also calls
+ * {@link attachBetterLocale} with the override store. `t()` then consults
+ * the store's active override id first; if it is `'ja'` (or any id whose
+ * dict has the requested key) the ja text wins, otherwise the existing
+ * zh/en chain runs unchanged. better-locale itself patches
+ * `LocaleRuntime.prototype.lookup` so DSH's own translate chain also
+ * returns ja where the `betterSidebar` namespace has a ja entry — that
+ * path covers external callers of `ctx.locale.bind('betterSidebar')`,
+ * while the override-aware `t()` here covers dsh-coding-sidebar's own
+ * components (which bypass `ctx.locale` and call `t()` directly).
+ */
+/** The zh dictionary (also registered into the DSH locale registry under {@link LOCALE_NS}). */
+export declare const zh: {
+    files: string;
+    explorer: string;
+    git: string;
+    terminal: string;
+    editor: string;
+    editorExplorer: string;
+    editorExplorerDesc: string;
+    editorExplorerMerged: string;
+    editorExplorerMergedDesc: string;
+    editorExplorerSplit: string;
+    editorExplorerSplitDesc: string;
+    editorTreeToggle: string;
+    editorPathPlaceholder: string;
+    editorSearchPlaceholder: string;
+    editorSearchNoResults: string;
+    editorSearchTruncated: string;
+    editorEmptyHint: string;
+    openFileNewTab: string;
+    openFileSide: string;
+    openWithMenu: string;
+    openWithSshSuffix: string;
+    pinOpenWith: string;
+    unpinOpenWith: string;
+    openWithExplorer: string;
+    openWithVscode: string;
+    openWithCursor: string;
+    openWithZed: string;
+    openWithSettingsSshTitle: string;
+    openWithSettingsSshDesc: string;
+    openWithSettingsSshPlaceholder: string;
+    openWithSettingsCustomTitle: string;
+    openWithSettingsCustomDesc: string;
+    openWithSettingsAdd: string;
+    openWithSettingsName: string;
+    openWithSettingsTemplate: string;
+    openWithSettingsFamily: string;
+    openWithSettingsFamilyDesc: string;
+    openWithSettingsRemove: string;
+    openWithSettingsInvalidHint: string;
+    newTab: string;
+    openExplorer: string;
+    brokenSymlink: string;
+    openGit: string;
+    newTerminal: string;
+    terminalLimit: string;
+    close: string;
+    closeOtherTabs: string;
+    closeLeftTabs: string;
+    closeRightTabs: string;
+    moveToFreeWindow: string;
+    floatDropHint: string;
+    dockToSidebar: string;
+    pinTerminal: string;
+    pinAgentTerminal: string;
+    pinToWorkspace: string;
+    pinToGlobal: string;
+    unpinTerminal: string;
+    pinnedTerminalTooltip: string;
+    pinnedTerminalKindUi: string;
+    pinnedTerminalKindAgent: string;
+    pinnedTerminalScopeWorkspace: string;
+    pinnedTerminalScopeGlobal: string;
+    pinnedRailLabel: string;
+    closePinnedTerminal: string;
+    collapse: string;
+    expand: string;
+    terminalError: string;
+    terminalConnectFailed: string;
+    terminalRetry: string;
+    terminalDepsFailed: string;
+    terminalDepsHint: string;
+    terminalDepsProfile: string;
+    preview: string;
+    toc: string;
+    edit: string;
+    mermaidError: string;
+    mermaidZoomIn: string;
+    mermaidZoomOut: string;
+    mermaidZoomReset: string;
+    mermaidZoomHint: string;
+    refresh: string;
+    refreshUnsavedConfirm: string;
+    save: string;
+    saved: string;
+    unsaved: string;
+    saveFailed: string;
+    truncation: string;
+    binary: string;
+    loading: string;
+    error: string;
+    retry: string;
+    splitLeft: string;
+    splitRight: string;
+    splitUp: string;
+    splitDown: string;
+    notRepo: string;
+    noChanges: string;
+    statusTruncated: string;
+    stage: string;
+    unstage: string;
+    stageAll: string;
+    unstageAll: string;
+    commitPlaceholder: string;
+    commit: string;
+    commitError: string;
+    branch: string;
+    worktree: string;
+    checkoutError: string;
+    history: string;
+    changes: string;
+    staged: string;
+    unstaged: string;
+    cancel: string;
+    diffEmpty: string;
+    diffLoadError: string;
+    diffBinary: string;
+    diffAdded: string;
+    diffDeleted: string;
+    diffRenamed: string;
+    diffExpand: string;
+    diffCollapse: string;
+    discard: string;
+    discardTitle: string;
+    discardDesc: string;
+    viewCommitDiff: string;
+    copyShortHash: string;
+    copyFullHash: string;
+    copySubject: string;
+    revertCommit: string;
+    revertTitle: string;
+    revertDesc: string;
+    cherryPickCommit: string;
+    cherryPickTitle: string;
+    cherryPickDesc: string;
+    timeJustNow: string;
+    timeMinutesAgo: string;
+    timeHoursAgo: string;
+    timeYesterday: string;
+    loadMore: string;
+    historyLoadError: string;
+    produced: string;
+    producedOpen: string;
+    showInFolder: string;
+    disconnected: string;
+    exited: string;
+    noSession: string;
+    pluginNotLoaded: string;
+    hiddenFiles: string;
+    parent: string;
+    copied: string;
+    copy: string;
+    newFile: string;
+    openEditor: string;
+    gitDetail: string;
+    referenceFile: string;
+    addToConversation: string;
+    copyRelative: string;
+    copyAbsolute: string;
+    download: string;
+    uploadFiles: string;
+    uploadFolder: string;
+    uploadHere: string;
+    uploadDropHint: string;
+    uploadDropChat: string;
+    uploadTo: string;
+    uploadingTo: string;
+    uploadProgress: string;
+    uploadDone: string;
+    uploadFailed: string;
+    uploadFailedUnknown: string;
+    uploadTooLarge: string;
+    uploadCancelled: string;
+    settingsNav: string;
+    settingsIntro: string;
+    settingsPopupDesc: string;
+    settingsDone: string;
+    settingsOpenTitle: string;
+    settingsOpenDesc: string;
+    settingsWidthTitle: string;
+    settingsWidthDesc: string;
+    settingsWidthSuffix: string;
+    settingsOpenPathTitle: string;
+    settingsOpenPathDesc: string;
+    settingsOpenToolsTitle: string;
+    settingsOpenToolsDesc: string;
+    settingsTitleBarTitle: string;
+    settingsTitleBarDesc: string;
+    settingsTitleBarStripTitle: string;
+    settingsTitleBarStripDesc: string;
+    settingsSchemeAutoTitle: string;
+    settingsSchemeAutoDesc: string;
+    settingsSchemeWebTitle: string;
+    settingsSchemeWebDesc: string;
+    settingsSchemeCustomTitle: string;
+    settingsSchemeCustomDesc: string;
+    settingsSchemeDetectedSuffix: string;
+    settingsCustomCssTitle: string;
+    settingsCustomCssDesc: string;
+    settingsCustomCssPlaceholder: string;
+    settingsSaveFailed: string;
+    settingsConflict: string;
+    binaryNoPreview: string;
+    downloadToView: string;
+    settingsSubagentTitle: string;
+    settingsSubagentDesc: string;
+    settingsJobsTitle: string;
+    settingsJobsDesc: string;
+    settingsToolsTitle: string;
+    settingsToolsDesc: string;
+    settingsFontFamilyTitle: string;
+    settingsFontFamilyDesc: string;
+    settingsFontFamilyPlaceholder: string;
+    settingsFontSizeTitle: string;
+    settingsFontSizeDesc: string;
+    settingsFontSizeSuffix: string;
+    settingsShellTitle: string;
+    settingsShellDesc: string;
+    settingsShellPlaceholder: string;
+    settingsShellArgsTitle: string;
+    settingsShellArgsDesc: string;
+    settingsShellArgsPlaceholder: string;
+    settingsTabsTitle: string;
+    settingsViewersTitle: string;
+    settingsGeneralTitle: string;
+    settingsPopup: string;
+    settingsViewerCatchAll: string;
+    viewerImage: string;
+    viewerPdf: string;
+    viewerMarkdown: string;
+    viewerCode: string;
+    viewerBinary: string;
+    viewerHtml: string;
+    browser: string;
+    browserPlaceholder: string;
+    browserGo: string;
+    browserBack: string;
+    browserForward: string;
+    browserStart: string;
+    browserBlockedScheme: string;
+    browserBlockedLoopback: string;
+    browserInvalid: string;
+    browserNoSandboxWarning: string;
+    htmlNoSandboxWarning: string;
+    sandboxStatusOn: string;
+    sandboxUnlock: string;
+    sandboxRestore: string;
+    settingsHtmlDefaultUnsafeTitle: string;
+    settingsHtmlDefaultUnsafeDesc: string;
+    settingsHtmlSandboxTitle: string;
+    settingsHtmlSandboxDesc: string;
+    settingsBrowserSandboxTitle: string;
+    settingsBrowserSandboxDesc: string;
+    settingsBrowserLinksTitle: string;
+    settingsBrowserLinksDesc: string;
+    settingsBrowserHttpTitle: string;
+    settingsBrowserHttpDesc: string;
+    settingsBrowserHttpsTitle: string;
+    settingsBrowserHttpsDesc: string;
+    settingsBrowserLoopbackTitle: string;
+    settingsBrowserLoopbackDesc: string;
+    settingsBrowserLoopbackPlaceholder: string;
+    browserOpenExternal: string;
+    browserEmbedBlocked: string;
+    browserEmbedBlockedDesc: string;
+    browserEmbedAnyway: string;
+    subagent: string;
+    openSubagent: string;
+    subagentMainAgent: string;
+    subagentEmpty: string;
+    subagentEmptyDesc: string;
+    subagentRunning: string;
+    subagentInactive: string;
+    subagentModeOneShot: string;
+    subagentModeContinuable: string;
+    subagentCount: string;
+    subagentCountRunning: string;
+    subagentDiagCorrupt: string;
+    subagentDiagUnsupported: string;
+    subagentDiagUnavailable: string;
+    subagentThinking: string;
+    sideChat: string;
+    sideChatNew: string;
+    sideChatUntitled: string;
+    sideChatEmpty: string;
+    sideChatEmptyDesc: string;
+    sideChatCreating: string;
+    sideChatRetry: string;
+    sideChatThreads: string;
+    sideChatSave: string;
+    sideChatSaveTitle: string;
+    sideChatSaved: string;
+    sideChatNoTurn: string;
+    sideChatPendingDrop: string;
+    sideChatFirstPlaceholder: string;
+    sideChatComposerPlaceholder: string;
+    sideChatThinking: string;
+    sideChatThink: string;
+    sideChatInjection: string;
+    sideChatSend: string;
+    sideChatCancel: string;
+    sideChatCancelTitle: string;
+    sideChatClose: string;
+    sideChatCloseTitle: string;
+    sideChatError: string;
+    jobs: string;
+    jobsCount: string;
+    jobsCountRunning: string;
+    jobStatusRunning: string;
+    jobStatusStopping: string;
+    jobStatusCompleted: string;
+    jobStatusKilled: string;
+    jobStatusFailed: string;
+    jobDurationSeconds: string;
+    jobDurationMinutes: string;
+    jobDurationHours: string;
+    jobViewOutput: string;
+    jobHideOutput: string;
+    jobNoOutput: string;
+    jobNotReadYet: string;
+    jobOutputTruncated: string;
+    jobOutputError: string;
+    jobKill: string;
+    jobKillConfirm: string;
+    jobKillError: string;
+    addPluginsTabCard: string;
+    addPluginsTabCardDesc: string;
+    addPluginsViewerCard: string;
+    addPluginsViewerCardDesc: string;
+    addPluginsTabDesc: string;
+    addPluginsViewerDesc: string;
+    addPluginsBrowseMore: string;
+    addPluginsSearch: string;
+    addPluginsNoMatch: string;
+    addPluginsRecommended: string;
+    addPluginsEmpty: string;
+    openPlugin: string;
+    copyInstall: string;
+    pluginOfficeDesc: string;
+    pluginFlowglassDesc: string;
+    pluginGitForgeDesc: string;
+    pluginGitRemotesDesc: string;
+    pluginSentinelDesc: string;
+    pluginSidebarQaDesc: string;
+    pluginSshTunnelDesc: string;
+    pluginTurnReviewDesc: string;
+    pluginVideoPreviewDesc: string;
+    pluginDocsPanelDesc: string;
+    pluginEgoBrowserDesc: string;
+};
+/** The en dictionary (key-set-equal to zh, enforced by the type annotation). */
+export declare const en: Record<keyof typeof zh, string>;
+/**
+ * The dictionary namespace this plugin owns in the DSH locale registry
+ * (`'sidebar'` is taken by DSH's own ui-sidebar, hence this distinct name).
+ */
+export declare const LOCALE_NS = "betterSidebar";
+/** The ja dictionary (key-set-equal to zh, enforced by the type annotation). */
+export declare const ja: Record<keyof typeof zh, string>;
+export declare const de: Record<keyof typeof zh, string>;
+export declare const fr: Record<keyof typeof zh, string>;
+export declare const pt: Record<keyof typeof zh, string>;
+export declare const ko: Record<keyof typeof zh, string>;
+export declare const ar: Record<keyof typeof zh, string>;
+export declare const hi: Record<keyof typeof zh, string>;
+export declare const id: Record<keyof typeof zh, string>;
+export declare const tr: Record<keyof typeof zh, string>;
+export declare const vi: Record<keyof typeof zh, string>;
+export declare const th: Record<keyof typeof zh, string>;
+export declare const ru: Record<keyof typeof zh, string>;
+export declare const it: Record<keyof typeof zh, string>;
+export declare const nl: Record<keyof typeof zh, string>;
+export declare const sv: Record<keyof typeof zh, string>;
+export declare const pl: Record<keyof typeof zh, string>;
+export declare const zhHK: Record<keyof typeof zh, string>;
+export declare const zhTW: Record<keyof typeof zh, string>;
+export declare const zhMO: Record<keyof typeof zh, string>;
+/**
+ * The better-locale override store attached by the client apply
+ * (absent → no override; the zh/en chain runs). The store's `active`
+ * field holds the user's chosen override id (e.g. `'ja'`); `undefined`
+ * means "no override, use DSH native zh/en".
+ *
+ * The override only takes effect when DSH's active locale is `'en'`
+ * (it borrows DSH's English slot to render a third language). While
+ * DSH is on `'zh'` the override is inert — `getOverride` returns
+ * `undefined` and `isOverrideActive` returns `false` — so `t()` and
+ * `isZh()` fall through to the native zh/en chain unchanged.
+ */
+declare let betterLocaleStore: {
+    readonly active: string | undefined;
+    getOverride(dshActive: string, ns: string, key: string): string | undefined;
+    isOverrideActive(dshActive: string): boolean;
+} | undefined;
+/**
+ * Attach (or detach, with undefined) the DSH locale service. The sidebar
+ * mounts its own React root outside the slot system's locale seat, so the
+ * service rides this module-level holder: components keep calling the plain
+ * `t()` function, and the Sidebar root's locale subscription re-renders the
+ * whole tree on switches.
+ */
+export declare function attachLocale(service: {
+    getSnapshot(): {
+        active: string;
+    };
+} | undefined): void;
+/**
+ * Attach (or detach, with undefined) the better-locale override store.
+ * When attached with an active override, `t()` consults the store's
+ * `getOverride(active, LOCALE_NS, key)` first; if it returns a string,
+ * that text wins over the zh/en chain. Detaching (or the store's active
+ * being `undefined`) restores the zh/en chain unchanged.
+ *
+ * The Sidebar root subscribes to the store separately (see Sidebar.tsx)
+ * so an override change re-renders the whole tree — the locale service's
+ * own revision bump (which better-locale triggers via `publish(active, true)`)
+ * does NOT fire the existing `localeRevision` uSES because that snapshot
+ * reads `getSnapshot().active` (unchanged) rather than `revision`.
+ */
+export declare function attachBetterLocale(store: typeof betterLocaleStore): void;
+/** Translate a copy key in the active locale (zh → zh, else en). */
+export type CopyKey = keyof typeof zh;
+/** Translate a copy key; `{name}` placeholders interpolate from `params`. */
+export declare function t(key: CopyKey, params?: Record<string, string | number>): string;
+/** Whether the active locale is Chinese (used for selectors). */
+export declare function isZh(): boolean;
+/** Format an ISO 8601 author date relative to now (刚刚 / N 分钟前 / N 小时前 / 昨天 / date). */
+export declare function relativeTime(iso: string): string;
+export {};

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

@@ -0,0 +1,96 @@
+/**
+ * Raw-HTML block detection for the markdown preview. The shared `MarkdownText`
+ * renders raw HTML as literal text (a chat-security stance), so a GitHub-style
+ * README (`<div align="center">` badge walls, `<details>` collapsibles with
+ * markdown inside, table cells full of inline tags) previews as source soup.
+ * This module's pure splitter lifts those HTML runs OUT of the markdown stream
+ * before rendering: markdown runs keep flowing through `MarkdownText` (shiki /
+ * KaTeX / GFM intact, mermaid chunk path unchanged) while HTML runs render as
+ * sanitized DOM (see markdown-html.tsx).
+ *
+ * Splitting follows CommonMark's shape closely enough for real-world READMEs:
+ * a line outside code fences that starts with a block-level tag (type-6 list
+ * below) or `<!--` opens an HTML run that extends to the next blank line
+ * (comments end at the line containing `-->`). Inline-only tags (`<b>`, `<br>`,
+ * `<a>`…) never open a run — they stay in the markdown stream and are handled
+ * by the inline pass instead. Unclosed block tags (`<details>` … markdown …
+ * `</details>`) are surfaced by {@link analyzeHtmlSegment} as ordered parts so
+ * the renderer can nest the in-between markdown inside the open element, the
+ * way GitHub's linear HTML output nests.
+ */
+/** A run of raw HTML lines lifted out of the markdown stream. */
+export interface HtmlSegment {
+    kind: 'html';
+    text: string;
+}
+/** A run of markdown source (may contain non-mermaid fences, inline HTML…). */
+export interface MarkdownHtmlSegment {
+    kind: 'markdown';
+    text: string;
+}
+export type MdHtmlSegment = MarkdownHtmlSegment | HtmlSegment;
+/** The doc-wide analysis the preview consumes (all pure, unit-tested here). */
+export interface AnalyzedMarkdownHtml {
+    /** The document split into markdown / html runs (empty input → []). */
+    segments: MdHtmlSegment[];
+    /** True when at least one html run was lifted out. */
+    hasBlockHtml: boolean;
+    /** True when the source contains any tag-like text (block OR inline). */
+    hasInlineHtml: boolean;
+    /** Every reference definition found in the markdown runs (`[label]: dest`
+     *  lines), joined — appended to each markdown run so `[text][id]` keeps
+     *  resolving across the lifted HTML runs (first-match wins makes the
+     *  appended copy inert inside runs that already define it). */
+    referenceDefinitions: string;
+}
+/**
+ * CommonMark HTML-block type-6 tag names (block-level elements), lowercased.
+ * A line starting with one of these (open or close) outside a fence begins an
+ * HTML run. `<summary>` is CommonMark-inline but intentionally included: it is
+ * the idiomatic first child of a `<details>` run in GitHub-flavored READMEs.
+ */
+export declare const HTML_BLOCK_TAGS: ReadonlySet<string>;
+/** One structural piece of a lifted HTML run, in document order. */
+export type HtmlPart = {
+    kind: 'html';
+    html: string;
+} | {
+    kind: 'open';
+    tag: string;
+    attrs: string;
+} | {
+    kind: 'close';
+    tag: string;
+};
+/** The run's structure relative to the surrounding document nesting. */
+export interface HtmlSegmentShape {
+    parts: HtmlPart[];
+}
+/**
+ * Reduce a lifted HTML run to ordered parts: balanced spans become `html`
+ * leaves, unclosed open tags become `open` (a wrapper the renderer lowers
+ * following markdown runs into), unmatched closes become `close` (pops one
+ * wrapper level). A mismatched close pops through the matching open — the
+ * HTML parser's implicit-close behavior. Runs with no structural tags reduce
+ * to a single `html` part.
+ */
+export declare function analyzeHtmlSegment(source: string): HtmlSegmentShape;
+/**
+ * Split markdown source into markdown / html runs (fence-aware: an HTML-looking
+ * line inside any fenced code block is content, not a run start). Blank lines
+ * terminate HTML runs and are dropped between segments (they carry no markdown
+ * semantics the preview needs); everything else stays byte-identical.
+ */
+export declare function splitHtmlBlocks(text: string): MdHtmlSegment[];
+/**
+ * Collect the reference definitions of every markdown run (HTML runs cannot
+ * define them), in document order, newline-joined for appending.
+ */
+export declare function collectReferenceDefinitions(segments: readonly MdHtmlSegment[]): string;
+/**
+ * The whole-document gate + split the preview consumes. `hasInlineHtml` is a
+ * cheap source-level regex (code-fence content may false-positive; the inline
+ * pass skips rendered code blocks anyway, so a false positive only costs the
+ * enhanced render path, never a behavior change).
+ */
+export declare function analyzeMarkdownHtml(text: string): AnalyzedMarkdownHtml;

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

@@ -0,0 +1,45 @@
+/**
+ * Markdown-preview local-image resolution. The shared `MarkdownText` (from
+ * @deepseek-ai/dsh-client-ui-primitives) only renders absolute http(s) image
+ * URLs — relative links are disabled for chat security — so a local image in
+ * a previewed `.md` (`![alt](./img.png)`, an absolute `/cwd/img.png`, or a
+ * reference definition) would otherwise fall back to its alt text. This
+ * dependency-free helper rewrites those destinations into absolute
+ * `/sidebar/file` media URLs (prefixed with the GUI's own origin) so
+ * `MarkdownText` accepts them; the host media route then serves the bytes,
+ * still restricted to files under the session cwd.
+ */
+import type { SessionScope } from './api.ts';
+/**
+ * Rewrite markdown image destinations that point at local files into
+ * absolute `/sidebar/file` media URLs. Relative destinations resolve against
+ * the opened file's directory (normalizing `.`/`..` segments); absolute
+ * local paths pass through. Remote (http/https/data/mailto) and `#`-anchor
+ * destinations are left untouched for `MarkdownText`. Reference-style images
+ * (`![x][id]` + `[id]: url`) are covered by rewriting their definition lines.
+ *
+ * Code spans (`` `...` ``) and fenced code blocks (``` ```...``` ```) are
+ * masked before rewriting so documentation that demonstrates `![alt](./img.png)`
+ * is not mutated into a `/sidebar/file` URL. Reference definitions are only
+ * rewritten when their label is actually referenced by an image (collapsed
+ * `[![][id]]`, full `![alt][id]`, or shortcut `![]` referencing the next
+ * definition) — a plain link `[text][id]` must not have its destination
+ * redirected to the media route.
+ * @param text - The raw markdown source (inline + reference images).
+ * @param scope - The session scope (sessionId + cwd) for the media route.
+ * @param filePath - The absolute path of the opened `.md` file.
+ * @param origin - The GUI's own origin (`window.location.origin`); injected
+ * so the core rewrite stays pure and unit-testable.
+ * @returns The markdown with local image destinations rewritten in place.
+ */
+/**
+ * Resolve one media destination against the session's media route: local
+ * (relative or absolute) paths become absolute `/sidebar/file` URLs (prefixed
+ * with the GUI's own origin so the shared MarkdownText http(s) allowlist
+ * accepts them), while remote URLs, `#`-anchors and empty destinations are
+ * returned untouched. Shared by the markdown image rewriter below and by the
+ * preview's raw-HTML sanitizer (`markdown-html.tsx`, which meets the same
+ * allowlist when rendering `<img src="./x.png">` inside HTML blocks).
+ */
+export declare function resolveLocalMediaDest(dest: string, scope: SessionScope, filePath: string, origin: string): string;
+export declare function rewriteLocalImageUrls(text: string, scope: SessionScope, filePath: string, origin: string): string;

package/lib/types/client/markdown-labels.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copy-button / chrome labels for DSH's shared `MarkdownText`, shaped for
+ * BOTH prop generations the plugin supports:
+ *
+ * - 0.1.1-rc.x: optional flat prop `codeLabels` — the renderer reads
+ *   `labels.copyLabel` / `labels.copiedLabel` directly.
+ * - 0.1.2-alpha.1+: renamed to a REQUIRED `labels` prop with a nested shape
+ *   (`labels.code.copyLabel` + a screen-reader-only `labels.footnotes`
+ *   heading). Passing only the old prop crashes the fence render with
+ *   "Cannot read properties of undefined (reading 'code')" — the exact
+ *   regression the mount lane caught on a real 0.1.2-alpha.1 host.
+ *
+ * The union object satisfies both readers, and {@link markdownTextProps}
+ * passes it under BOTH prop names — each host ignores the one it does not
+ * know. `footnotes` is left empty (the heading is sr-only; give it a real
+ * string only if a locale key ever earns its place in all 19 dictionaries).
+ */
+import type { ComponentProps } from 'react';
+import { MarkdownText } from '@deepseek-ai/dsh-client-ui-primitives';
+/** The flat copy-button pair the plugin threads through its own props
+ *  (e.g. MermaidMarkdownProps.codeLabels — the chunk contract stays put). */
+export interface MarkdownCopyLabels {
+    copyLabel: string;
+    copiedLabel: string;
+}
+/** The dual-generation chrome labels object (see module doc). */
+export interface MarkdownChromeLabels extends MarkdownCopyLabels {
+    /** 0.1.2-alpha.1+ nested reads. */
+    code: MarkdownCopyLabels;
+    /** 0.1.2-alpha.1+ sr-only footnotes heading. */
+    footnotes: string;
+}
+/** Build the dual-shape chrome labels from a flat copy-button pair. */
+export declare function markdownChromeLabels(labels: MarkdownCopyLabels): MarkdownChromeLabels;
+/** MarkdownText props carrying the labels under BOTH prop names. The cast is
+ *  load-bearing: the plugin builds against the 0.1.1-rc.x declaration, where
+ *  `labels` does not exist yet (and vice versa on a 0.1.2-alpha.1+ host). */
+export declare function markdownTextProps(text: string, labels: MarkdownCopyLabels): ComponentProps<typeof MarkdownText>;

package/lib/types/client/md-toc.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+/** Fewer headings than this and the button stays hidden (no outline value). */
+export declare const TOC_MIN_HEADINGS = 3;
+export declare function MdToc(): ReactNode;

package/lib/types/client/mermaid-blocks.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Markdown/mermaid fence detection for the markdown preview. The preview
+ * renders the WHOLE document through one DSH `MarkdownText` pass (so
+ * cross-fence semantics — reference-style links, footnotes, list
+ * continuity — stay intact) and the mermaid lazy chunk then swaps the
+ * rendered `language-mermaid` code blocks for diagrams. This module's pure
+ * splitter exists to detect whether the source contains a mermaid fence at
+ * all, so the mermaid chunk is only fetched when needed (unit-tested in
+ * tests/mermaid-blocks.spec.ts).
+ */
+/** One fenced mermaid diagram lifted out of the markdown source. */
+export interface MermaidBlock {
+    kind: 'mermaid';
+    /** The raw diagram source between the fences (info string stripped). */
+    code: string;
+}
+/** A span of plain markdown source (may itself contain non-mermaid fences). */
+export interface MarkdownBlock {
+    kind: 'markdown';
+    text: string;
+}
+export type MdBlock = MarkdownBlock | MermaidBlock;
+/** Props of the chunk-resident `MermaidMarkdown` component (shared contract). */
+export interface MermaidMarkdownProps {
+    /** The full markdown source (rendered in a single MarkdownText pass). */
+    text: string;
+    codeLabels: {
+        copyLabel: string;
+        copiedLabel: string;
+    };
+}
+/** CommonMark opening fence: 0-3 spaces indent + a run of 3+ backticks or tildes. */
+export declare const OPEN_FENCE_RE: RegExp;
+/** A closing-fence line: 0-3 spaces indent + 3+ backticks/tildes + trailing spaces only. */
+export declare const CLOSE_FENCE_RE: RegExp;
+/** Parse the info string from the line tail after the fence run; null when invalid. */
+export declare function fenceInfo(rest: string, fence: string): string | null;
+/**
+ * Split markdown source into md/mermaid blocks for detection: only fences
+ * whose info string names mermaid are lifted; every other line stays in the
+ * markdown stream untouched. CommonMark fence rules are honored — opening
+ * fences of 3+ backticks OR tildes, and a closing fence must use the same
+ * character with at least as many characters as the opening fence. An
+ * unterminated mermaid fence swallows the rest of the file (the same
+ * recovery CommonMark applies to open fences).
+ */
+export declare function splitMermaidBlocks(text: string): MdBlock[];

package/lib/types/client/mermaid-sanitize.d.ts

@@ -0,0 +1,2 @@
+/** A parse failure keeps nothing of the input: the caller shows the error. */
+export declare function sanitizeSvg(svg: string): string;