@deepseek-ai/dsh-client-ui-primitives 0.0.1-rc.1

package/lib/types/ansi.d.ts

@@ -0,0 +1,17 @@
+import type { CSSProperties } from 'react';
+/** One run of terminal text; `style` is undefined for text that carries no SGR state. */
+export interface AnsiSpan {
+    /** The run's plain text, free of escape sequences and newlines. */
+    text: string;
+    /** Resolved inline style, or undefined when the run needs no wrapper. */
+    style: CSSProperties | undefined;
+}
+/** The spans of one output line, in order. */
+export type AnsiLine = readonly AnsiSpan[];
+/**
+ * Parse command output into styled spans grouped by line.
+ * @param text - raw output text, which may contain ANSI escape sequences.
+ * @returns one entry per output line (always at least one, possibly empty).
+ */
+export declare function parseAnsiLines(text: string): AnsiLine[];
+//# sourceMappingURL=ansi.d.ts.map

package/lib/types/clipboard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Write text to the host clipboard, preferring the async Clipboard API and
+ * falling back to `execCommand('copy')` on hosts (jsdom, insecure contexts)
+ * that omit it.
+ * @param text - the exact text to place on the clipboard.
+ * @returns true only when the host accepted the write.
+ */
+export declare function writeClipboard(text: string): Promise<boolean>;
+//# sourceMappingURL=clipboard.d.ts.map

package/lib/types/head-tail-cap.d.ts

@@ -0,0 +1,23 @@
+/** The head/tail split metrics for a capped list. */
+export interface HeadTailCap {
+    /** Rows beyond the cap (list length − maxLines); ≤ 0 means nothing is hidden. */
+    hidden: number;
+    /** Whether the list is over the cap and not expanded, so it shows a head/tail slice. */
+    capped: boolean;
+    /** Head-slice row count: `ceil(maxLines / 2)`. */
+    headLines: number;
+    /** Tail-slice row count: the remainder after the head. */
+    tailLines: number;
+}
+/**
+ * Compute the head/tail cap metrics for a list of `total` rows against `maxLines`,
+ * given whether the surface is expanded. Pure arithmetic; the caller slices its
+ * own rows with `headLines`/`tailLines` so a block can layer its own concerns
+ * (SearchBlock restores a tail file header) on top.
+ * @param total - the list's row count.
+ * @param maxLines - the collapsed-height cap in rows.
+ * @param expanded - whether the surface is expanded (uncaps the list).
+ * @returns the split metrics.
+ */
+export declare function headTailCap(total: number, maxLines: number, expanded: boolean): HeadTailCap;
+//# sourceMappingURL=head-tail-cap.d.ts.map

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

@@ -0,0 +1,150 @@
+/**
+ * ic_ds_* icon set for the dsh web UI. All glyphs render fill="currentColor"
+ * and take {size, className}. Batch A mirrors the deepsuite icon library
+ * (same figma source); batch B glyphs are harness-only figma extracts.
+ */
+import type { IconProps } from './props.ts';
+export type { IconProps } from './props.ts';
+/** ic_ds_new_chat_outline_16 */
+export declare const IconNewChatOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_search_outline_16 */
+export declare const IconSearchOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_settings_outline_14 */
+export declare const IconSettingsOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_settings_outline_16 */
+export declare const IconSettingsOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_panel_left_outline_16 */
+export declare const IconPanelLeftOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_ellipsis_outline_16 */
+export declare const IconEllipsisOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_plus_outline_16 */
+export declare const IconPlusOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_check_outline_16 */
+export declare const IconCheckOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_check_outline_14 */
+export declare const IconCheckOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_branch_outline_16 */
+export declare const IconBranchOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_down_outline_14 */
+export declare const IconChevronDownOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_left_outline_14 */
+export declare const IconChevronLeftOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_right_outline_14 */
+export declare const IconChevronRightOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_triangle_right_fill_14 — tree expand arrow; points right, consumers rotate it 90° for the open state. */
+export declare const IconTriangleRightFill14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_up_outline_14 */
+export declare const IconChevronUpOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_close_outline_16 */
+export declare const IconCloseOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_close_fill_14 */
+export declare const IconCloseFill14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_copy_outline_16 */
+export declare const IconCopyOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_refresh_outline_16 */
+export declare const IconRefreshOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_refresh_outline_14 */
+export declare const IconRefreshOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_like_outline_16 */
+export declare const IconLikeOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_like_fill_16 */
+export declare const IconLikeFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_dislike_outline_16 */
+export declare const IconDislikeOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_dislike_fill_16 */
+export declare const IconDislikeFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_share_outline_16 */
+export declare const IconShareOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_edit_outline_16 */
+export declare const IconEditOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_think_outline_14 */
+export declare const IconThinkOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_think_outline_16 */
+export declare const IconThinkOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_browse_outline_16 */
+export declare const IconBrowseOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_link_outline_14 */
+export declare const IconLinkOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_link_outline_16 */
+export declare const IconLinkOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_right_up_outline_14 */
+export declare const IconRightUpOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_right_up_outline_16 */
+export declare const IconRightUpOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_enhance_outline_16 */
+export declare const IconEnhanceOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_trash_outline_16 */
+export declare const IconTrashOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_warning_outline_16 */
+export declare const IconWarningOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_user_outline_16 */
+export declare const IconUserOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_send_outline_16 */
+export declare const IconSendOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_stop_fill_16 */
+export declare const IconStopFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_paperclip_outline_16 */
+export declare const IconPaperclipOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_loading_outline_16 */
+export declare const IconLoadingOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_download_outline_16 */
+export declare const IconDownloadOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_play_outline_16 */
+export declare const IconPlayOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_pause_outline_16 */
+export declare const IconPauseOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_fullscreen_outline_16 */
+export declare const IconFullscreenOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_code_outline_16 */
+export declare const IconCodeOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_api_outline (figma extract) */
+export declare const IconApiOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_personalization_outline_16 (figma extract) */
+export declare const IconPersonalizationOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_project_add_outline_16 (figma extract) */
+export declare const IconProjectAddOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/**
+ * folder_open_16, outline layer only: the duotone original above reads a rung
+ * heavier than the …Outline16 family, so an icon-button row mixing them looks
+ * mismatched — this is the same geometry without the 20%-opacity inner fill.
+ */
+export declare const IconFolderOpenOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** folder_open_16 (figma extract): outline at full ink + 20%-opacity inner fill riding the same currentColor. */
+export declare const IconFolderOpen16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** folder_close_16 (figma extract) */
+export declare const IconFolderClose16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** tree_corner_8x10 (figma extract; session-tree "L" connector, stroke geometry pre-expanded) */
+export declare const IconTreeCorner8x10: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_light_outline_16 */
+export declare const IconLightOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_dark_outline_16 */
+export declare const IconDarkOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_followsystem_outline_16 */
+export declare const IconFollowsystemOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_data_outline_16 */
+export declare const IconDataOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_send_outline_14 (figma extract): thin-stroke upward send arrow. */
+export declare const IconSendOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_queue_outline_14 (figma extract): open chat bubble with two queued lines. */
+export declare const IconQueueOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_checklist_outline_14 (figma extract): two rings + two list bars. */
+export declare const IconChecklistOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_List_Pen_outline_16 */
+export declare const IconListPenOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_goal_outline_16 (goal strip leading glyph: dartboard with a landed arrow) */
+export declare const IconGoalOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** sparkle_16 (Others tool-row leading glyph; hand-authored three-star
+ *  approximation — the figma 43:31850 glyph is an SF Symbols "sparkles" text glyph,
+ *  not extractable as vector data) */
+export declare const IconSparkle16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** inspect_outline_12 (shared tool-row trajectory affordance glyph) */
+export declare const IconInspectOutline12: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** skill_outline_16 (skill tool-row glyph; document instructions + sparkle) */
+export declare const IconSkillOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_question_outline_14 (figma extract): ring + question glyph. */
+export declare const IconQuestionOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_archive_outline_20 (figma extract): lidded box + label slot. The export's
+ *  0.11px stroke ring around the box contour is dropped — it restates the same
+ *  contour in the same ink, which currentColor already carries. */
+export declare const IconArchiveOutline20: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,9 @@
+/** Shared props for every ic_ds_* icon component. */
+export interface IconProps {
+    /** Square edge in px; defaults to the glyph's own drawn size. */
+    size?: number | undefined;
+    /** Extra class for layout placement; color rides currentColor.
+     * (`| undefined` for exactOptionalPropertyTypes: callers forward their own optional prop.) */
+    className?: string | undefined;
+}
+//# sourceMappingURL=props.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Cordis-free React primitives styled only through `--dsw-*` tokens.
+ */
+export { StateDot } from './StateDot.tsx';
+export type { StateDotState } from './StateDot.tsx';
+export { DisclosureRow } from './DisclosureRow.tsx';
+export type { DisclosureRowProps } from './DisclosureRow.tsx';
+export { Button } from './Button.tsx';
+export type { ButtonVariant } from './Button.tsx';
+export { Pill } from './Pill.tsx';
+export { Input } from './Input.tsx';
+export { Menu } from './Menu.tsx';
+export type { MenuEntry, MenuItem, MenuSeparator, MenuLabel } from './Menu.tsx';
+export { useAnchoredMaxHeight } from './useAnchoredMaxHeight.ts';
+export { HoverCard } from './HoverCard.tsx';
+export { Modal } from './Modal.tsx';
+export { OnboardingSurface } from './OnboardingSurface.tsx';
+export { RiskConfirmation } from './RiskConfirmation.tsx';
+export type { RiskConfirmationProps } from './RiskConfirmation.tsx';
+export { ConnectionBanner } from './ConnectionBanner.tsx';
+export { FishLogo } from './FishLogo.tsx';
+export { BrandWordmark } from './BrandWordmark.tsx';
+export { Tooltip } from './Tooltip.tsx';
+export type { TooltipSide } from './Tooltip.tsx';
+export { writeClipboard } from './clipboard.ts';
+export { JsonTree } from './JsonTree.tsx';
+export type { JsonTreeProps, JsonTreeLabels } from './JsonTree.tsx';
+export { TerminalBlock, DEFAULT_TERMINAL_MAX_LINES } from './TerminalBlock.tsx';
+export type { TerminalBlockProps, TerminalBlockLabels } from './TerminalBlock.tsx';
+export { ReadBlock, DEFAULT_READ_MAX_LINES } from './ReadBlock.tsx';
+export type { ReadBlockProps, ReadBlockLine } from './ReadBlock.tsx';
+export { DiffBlock, DEFAULT_DIFF_MAX_LINES } from './DiffBlock.tsx';
+export type { DiffBlockProps, DiffHunk } from './DiffBlock.tsx';
+export { SearchBlock, DEFAULT_SEARCH_MAX_LINES } from './SearchBlock.tsx';
+export type { SearchBlockProps, SearchMatchesBlockProps, SearchPathsBlockProps, SearchFileGroup, SearchBlockLineMatch, } from './SearchBlock.tsx';
+export { WebBlock } from './WebBlock.tsx';
+export type { WebBlockProps, WebSearchBlockProps, WebFetchBlockProps, WebSourceView } from './WebBlock.tsx';
+export { CodeBlock } from './markdown/CodeBlock.tsx';
+export type { CodeBlockProps } from './markdown/CodeBlock.tsx';
+export { JsonBlock } from './markdown/JsonBlock.tsx';
+export { MarkdownText } from './markdown/MarkdownText.tsx';
+export type { MarkdownCodeLabels, MarkdownFileMentions } from './markdown/MarkdownText.tsx';
+export { MessageText } from './markdown/MessageText.tsx';
+export { extractMarkdownPlainText } from './markdown/plain-text.ts';
+export type { MarkdownPlainTextMode, MarkdownPlainTextOptions } from './markdown/plain-text.ts';
+export * from './icons/index.tsx';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-client-ui-primitives`.
+ * @module @deepseek-ai/dsh-client-ui-primitives/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-ui-primitives-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/markdown/CodeBlock.d.ts

@@ -0,0 +1,14 @@
+export interface CodeBlockProps {
+    /** The source text, rendered verbatim (trailing newline trimmed for display). */
+    code: string;
+    /** Grammar hint (markdown fence info string or a fixed caller id); unknown = plain. */
+    lang?: string | undefined;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+    /** Copy-button idle label; the owner passes localized copy (this package is cordis-free, so copy arrives via props). */
+    copyLabel?: string | undefined;
+    /** Copy-button label during the post-copy confirmation window. */
+    copiedLabel?: string | undefined;
+}
+export declare function CodeBlock({ code, lang, className, copyLabel, copiedLabel }: CodeBlockProps): import("react").JSX.Element;
+//# sourceMappingURL=CodeBlock.d.ts.map

package/lib/types/markdown/JsonBlock.d.ts

@@ -0,0 +1,8 @@
+export declare function JsonBlock({ label, payload, defaultOpen, truncatedLabel }: {
+    label: string;
+    payload: unknown;
+    defaultOpen?: boolean;
+    /** Footer appended when the body exceeds the char cap, given the full length (this package is cordis-free, so copy arrives via props). */
+    truncatedLabel?: ((total: number) => string) | undefined;
+}): import("react").JSX.Element;
+//# sourceMappingURL=JsonBlock.d.ts.map

package/lib/types/markdown/MarkdownText.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Untrusted assistant-Markdown renderer over the direct mdast pipeline:
+ * `parse.ts` grammars, the incremental streaming parser, and `render.tsx`.
+ * While a message streams, all but the trailing two blocks freeze as cached
+ * React elements and only the source tail behind them re-parses per chunk,
+ * so per-chunk work tracks the tail size instead of the whole reply. Frozen
+ * blocks keep their source-offset keys when they cross the freeze boundary,
+ * so React reconciles instead of remounting. Known deviation while
+ * streaming: a reference-style link or footnote whose definition sits on the
+ * other side of the freeze boundary renders literally until the settled
+ * full parse self-heals it.
+ */
+import type { MarkdownCodeLabels, MarkdownFileMentions } from './render.tsx';
+import 'katex/dist/katex.min.css';
+export type { MarkdownCodeLabels, MarkdownFileMentions } from './render.tsx';
+/**
+ * Render untrusted assistant-authored Markdown as semantic React elements.
+ * @param props - Markdown source text preserved by the session projection;
+ * `streaming` renders fences and TeX plain (highlighting and KaTeX land on
+ * the finalize swap) and parses incrementally across chunks; `codeLabels`
+ * forwards localized copy-button labels to fence CodeBlocks — pass a
+ * reference-stable object (memoized per locale revision), because a new
+ * identity discards the streaming render cache mid-message. `fileMentions`
+ * links inline-code tokens its resolver recognizes as real files; this is
+ * the single streaming gate — it applies to settled renders only, because a
+ * streaming message's vocabulary is not final and frozen cached elements
+ * must not bake in handlers that could go stale.
+ * @returns A GFM document with TeX math rendered through KaTeX; raw HTML,
+ * relative links, and unsafe protocols are disabled, while absolute HTTP(S)
+ * images render directly.
+ */
+export declare const MarkdownText: import("react").MemoExoticComponent<({ text, streaming, codeLabels, fileMentions }: {
+    text: string;
+    streaming?: boolean;
+    codeLabels?: MarkdownCodeLabels | undefined;
+    fileMentions?: MarkdownFileMentions | undefined;
+}) => import("react").JSX.Element>;
+//# sourceMappingURL=MarkdownText.d.ts.map

package/lib/types/markdown/MessageText.d.ts

@@ -0,0 +1,4 @@
+export declare function MessageText({ text }: {
+    text: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=MessageText.d.ts.map

package/lib/types/markdown/cjkFriendlyStrong.d.ts

@@ -0,0 +1,9 @@
+/** Let asterisk strong emphasis close after punctuation when CJK prose continues without whitespace. */
+import type { Extension } from 'micromark-util-types';
+/**
+ * Extend CommonMark asterisk strong emphasis for punctuation-delimited CJK
+ * prose, as a micromark syntax extension for `fromMarkdown`.
+ * @returns The micromark syntax extension.
+ */
+export declare function cjkFriendlyStrong(): Extension;
+//# sourceMappingURL=cjkFriendlyStrong.d.ts.map

package/lib/types/markdown/highlight.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The client's ONE syntax highlighter: a synchronous fine-grained shiki core
+ * (JavaScript regex engine — no oniguruma WASM, bundle-friendly) with an
+ * explicit grammar allowlist and a CSS-variables theme. Colors live in the
+ * theme package's token sheets as `--shiki-*` custom properties (light and
+ * dark blocks), never here — the repo's tokens-only styling rule.
+ *
+ * Only the three markdown-fence and `run_code` grammars (TypeScript, shell,
+ * JSON) load into the singleton at boot — the set every session renders. The
+ * read card's wider extension set (the file-extension language hints the read
+ * tool's `langFromPath` emits — `packages/fs/tool-fs`: python, rust, yaml,
+ * markup, …) is imported lazily and registered the first time such a language
+ * is requested, so a session that never opens a read card in one of those
+ * languages pays neither the ~1.6 MB of grammar modules nor their synchronous
+ * init. The first render of a lazy language falls back to plain text while its
+ * grammar loads, then {@link onGrammarLoaded} notifies subscribers to re-render
+ * with highlighting. An unknown or absent language falls back to plain text (no
+ * highlighting, still monospace) — never an error.
+ */
+import type { CSSProperties } from 'react';
+/**
+ * Subscribe to lazy-grammar load completions; `listener` fires after a
+ * {@link LAZY_GRAMMARS} grammar finishes registering on the singleton, so a
+ * caller that rendered its plain fallback while the grammar loaded can
+ * re-highlight. Uses the `useSyncExternalStore` subscribe signature; pair it with
+ * {@link grammarLoadCount} as the snapshot. Returns an unsubscribe function.
+ * @param listener - invoked (no args) on each grammar-load completion.
+ * @returns a disposer that removes the listener.
+ */
+export declare function subscribeGrammarLoaded(listener: () => void): () => void;
+/**
+ * The lazy-grammar load counter — a value that changes on every load, so a
+ * `useSyncExternalStore` snapshot re-renders the subscriber when a grammar
+ * registers. Opaque: only its identity across renders matters.
+ * @returns the current load count.
+ */
+export declare function grammarLoadCount(): number;
+/**
+ * Highlight `code` into shiki's HTML (a single `<pre class="shiki">` tree)
+ * when `lang` maps to a registered grammar; `undefined` means the caller
+ * renders its plain fallback. A lazy grammar not yet loaded returns `undefined`
+ * for this call and loads in the background; subscribe with
+ * {@link onGrammarLoaded} to re-highlight once it registers.
+ * @param code - the source text.
+ * @param lang - the language hint (a markdown fence info string or a fixed caller id).
+ * @returns the highlighted HTML, or `undefined` for unknown or not-yet-loaded languages.
+ */
+export declare function highlightToHtml(code: string, lang: string | undefined): string | undefined;
+/**
+ * One highlighted run of a line: the text and the inline style shiki assigned
+ * it. The css-variables theme colors every run through a `--shiki-*` custom
+ * property, so `style.color` is always present; it is held as a style object
+ * rather than a bare color so a run spreads onto a `<span style>` uniformly.
+ */
+export interface HighlightSpan {
+    text: string;
+    style: CSSProperties;
+}
+/**
+ * Tokenize `code` into per-line highlighted runs when `lang` maps to a
+ * registered grammar; `undefined` means the caller renders its plain fallback.
+ * A line-numbered view needs the token runs split per line (one gutter number
+ * per line), which the single-`<pre>` {@link highlightToHtml} does not expose,
+ * so this returns shiki's own 2D line/token structure narrowed to what a run
+ * renders. Each run's color is a `--shiki-*` custom property, keeping token
+ * colors on the theme package's sheets exactly as the HTML path does; the
+ * css-variables theme carries no font-style bits, matching that path's
+ * color-only output. The trailing newline shiki appends as a final empty line
+ * is dropped so the run count matches the caller's own line array.
+ * @param code - the source text.
+ * @param lang - the language hint (a file-extension-derived language id).
+ * @returns one entry per source line (each an array of runs), or `undefined` for unknown or not-yet-loaded languages.
+ */
+export declare function highlightLines(code: string, lang: string | undefined): HighlightSpan[][] | undefined;
+//# sourceMappingURL=highlight.d.ts.map

package/lib/types/markdown/incremental.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Incremental block-level markdown parsing for an append-only text stream.
+ *
+ * Re-parsing the whole accumulated document on every streaming chunk is
+ * quadratic in the final reply length. CommonMark block parsing is line-based
+ * and appended text can only reshape the parse frontier — the last top-level
+ * block (a paragraph becoming a setext heading or a table, a list continuing
+ * after a blank line, an unclosed fence swallowing lines) — so earlier blocks
+ * are final. This parser therefore freezes all but the trailing
+ * {@link UNSTABLE_TAIL_BLOCKS} blocks and re-parses only the source tail
+ * behind them: each source region is parsed O(1) times over the stream
+ * instead of once per chunk.
+ *
+ * The freeze boundary comes from the parser's own `position` offsets, never
+ * from custom source scanning. The cut sits at the *end offset* of the last
+ * frozen block (not the next block's start): a following block's start offset
+ * excludes up to three spaces of insignificant leading indentation, which is
+ * harmless to drop, but cutting at the previous end also keeps the
+ * inter-block blank lines in the tail so the sliced source stays verbatim.
+ *
+ * Known deviation, shared with any prefix-freeze scheme: micromark resolves
+ * reference-style links and footnotes document-wide at parse time, so a
+ * reference whose definition lands on the other side of the freeze boundary
+ * renders literally until the settled full parse self-heals it.
+ */
+import type { Root, RootContent } from 'mdast';
+/** A top-level mdast block plus a render key that is stable across chunks. */
+export interface PositionedBlock {
+    /** The parsed block. Positions inside it are relative to its parse slice. */
+    readonly node: RootContent;
+    /**
+     * The block's start offset in the full source text. Stable from the frame
+     * a block first appears through freezing, so React reconciles rather than
+     * remounts when a block crosses the freeze boundary.
+     */
+    readonly key: number;
+}
+/** One {@link IncrementalMarkdownParser.update} result. */
+export interface IncrementalBlocks {
+    /** Blocks that can no longer change; grows monotonically per generation. */
+    readonly frozen: readonly PositionedBlock[];
+    /** The re-parsed unstable tail (at most {@link UNSTABLE_TAIL_BLOCKS} blocks plus growth). */
+    readonly tail: readonly PositionedBlock[];
+    /** Bumped whenever non-append input discards the frozen prefix; callers drop caches keyed on it. */
+    readonly generation: number;
+}
+/**
+ * Append-only incremental parser over a caller-supplied grammar. One instance
+ * accumulates one streaming document; non-append input resets it.
+ */
+export declare class IncrementalMarkdownParser {
+    private readonly parse;
+    private prevText;
+    private tailStart;
+    private frozen;
+    private generation;
+    private cached;
+    /** @param parse - Grammar shared with whatever renders the blocks, so boundaries agree. */
+    constructor(parse: (text: string) => Root);
+    /**
+     * Fold the current accumulated text and return the frozen/tail split.
+     * Idempotent for identical input (the previous result is returned as-is),
+     * so callers may invoke it from render paths that re-execute.
+     * @param text - The full accumulated markdown source.
+     * @returns Frozen and tail blocks with stream-stable render keys.
+     */
+    update(text: string): IncrementalBlocks;
+}
+//# sourceMappingURL=incremental.d.ts.map

package/lib/types/markdown/katex.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TeX-to-React via KaTeX, replicating the rehype-katex pipeline this renderer
+ * replaced: the same three-arm error chain (strict render, `strict: 'ignore'`
+ * retry, error span) and a DOM-identical element tree, so settled math keeps
+ * its exact markup. KaTeX emits an HTML string; the browser's own HTML parser
+ * (`DOMParser`, applying the spec's SVG/MathML foreign-content attribute
+ * adjustments KaTeX output relies on) turns it into a tree this module maps
+ * onto React elements — KaTeX output is a static span/MathML/SVG vocabulary
+ * with no raw user HTML, the same trust shiki's tree gets in CodeBlock.
+ *
+ * React 18 has no MathML support, so the `.katex-mathml` subtree's elements
+ * land in the HTML namespace — exactly as they did under the replaced
+ * hast-util-to-jsx-runtime pipeline. The visual arm is the `.katex-html`
+ * span tree; the MathML arm serves assistive technology, which reads it by
+ * tag name regardless of namespace.
+ */
+import type { ReactNode } from 'react';
+/**
+ * Render TeX source to React elements through KaTeX.
+ * @param value - The TeX source (math node value; fenced `math` blocks append
+ * their trailing newline to match the replaced pipeline's text extraction).
+ * @param displayMode - Display (block) versus inline rendering.
+ * @returns KaTeX's element tree, or the error span when the source does not
+ * parse (colored with KaTeX's stock `errorColor`, matching rehype-katex).
+ */
+export declare function renderTexToReact(value: string, displayMode: boolean): ReactNode;
+//# sourceMappingURL=katex.d.ts.map

package/lib/types/markdown/mathCompatibility.d.ts

@@ -0,0 +1,11 @@
+/** Extend upstream dollar-only math syntax with TeX delimiters while reusing its token vocabulary. */
+import type { Extension } from 'micromark-util-types';
+/**
+ * TeX backslash delimiters and same-line display-dollar blocks as a micromark
+ * syntax extension reusing `micromark-extension-math`'s token vocabulary; the
+ * caller must also register `math()` on the same parse so the emitted tokens
+ * compile to standard math nodes.
+ * @returns The micromark syntax extension.
+ */
+export declare function mathCompatibility(): Extension;
+//# sourceMappingURL=mathCompatibility.d.ts.map

package/lib/types/markdown/parse.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The markdown renderer's two mdast grammars, one per rendering arm. Each
+ * arm is internally consistent — the incremental tail parses, the one-shot
+ * parses, and the plain-text projection of a given grammar always agree on
+ * where blocks start and end — and the settled grammar is the streaming one
+ * plus the math extensions, so the arms differ only where TeX delimiters
+ * begin a math construct (a `$$` block is a paragraph while streaming and a
+ * math block once settled, by design).
+ */
+import type { Root } from 'mdast';
+/**
+ * Parse GFM markdown (the streaming arm's grammar: no math, so incomplete
+ * TeX never flashes KaTeX errors mid-stream).
+ * @param text - Markdown source.
+ * @returns The mdast root.
+ */
+export declare function parseGfm(text: string): Root;
+/**
+ * Parse GFM markdown plus TeX math with the compatibility delimiters
+ * (the settled arm's grammar).
+ * @param text - Markdown source.
+ * @returns The mdast root.
+ */
+export declare function parseGfmWithMath(text: string): Root;
+//# sourceMappingURL=parse.d.ts.map

package/lib/types/markdown/plain-text.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Markdown-to-plain-text projection for compact summaries and labels.
+ * Parsing shares the renderer's streaming GFM grammar ({@link parseGfm}), so
+ * the projection strips exactly the markup the renderer would draw; raw HTML
+ * stays literal, links keep their labels, images keep alt text, and code
+ * keeps its source text.
+ */
+/** Amount of parsed Markdown content returned by the extractor. */
+export type MarkdownPlainTextMode = 'all' | 'first-line' | 'first-paragraph';
+/** Options for {@link extractMarkdownPlainText}. */
+export interface MarkdownPlainTextOptions {
+    /** Projection boundary; defaults to the complete document. */
+    mode?: MarkdownPlainTextMode;
+}
+/**
+ * Parse GFM Markdown, remove its presentation markup, and preserve raw HTML literally.
+ * @param markdown - Markdown source.
+ * @param options - Optional extraction boundary.
+ * @returns Plain text for the whole document, first visible line, or first semantic paragraph.
+ */
+export declare function extractMarkdownPlainText(markdown: string, options?: MarkdownPlainTextOptions): string;
+//# sourceMappingURL=plain-text.d.ts.map