@songtonyli/dsh-cli 0.1.12 → 0.1.13

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/markdown/highlight.d.ts

@@ -0,0 +1,142 @@
+/**
+ * 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';
+/**
+ * Whether a language hint can use the shared syntax highlighter.
+ * @param lang - Language hint from a code surface.
+ * @returns Whether the hint resolves to a supported grammar.
+ */
+export declare function supportsHighlighting(lang: string | undefined): boolean;
+/**
+ * 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;
+}
+/**
+ * Incremental highlighter for one growing streaming fence. TextMate
+ * tokenization is line-based and forward-only — a line's tokens depend only on
+ * its own text and the grammar state entering it — so appended text never
+ * changes a completed line's tokens. The session caches the spans of every
+ * completed line together with the grammar state after them;
+ * {@link updateFrame} reports only newly completed lines plus the still-growing
+ * last line, while {@link update} materializes the complete compatibility
+ * result. Per-call tokenization cost therefore excludes the completed prefix,
+ * and the result equals a from-scratch tokenization of the same code.
+ * Non-append input and a change of resolved grammar reset the cache and
+ * re-tokenize fully, so any input stays correct.
+ */
+export declare class StreamingHighlightSession {
+    /** Grammar id the cache was built with; a different resolution resets it. */
+    private resolved;
+    /** Newline-terminated source prefix covered by {@link spans}. */
+    private prefix;
+    /** Cached spans, one entry per completed line of {@link prefix}. */
+    private spans;
+    /** Grammar state after {@link prefix}; undefined = the grammar's initial state. */
+    private state;
+    private lastCode;
+    private lastLang;
+    private lastResult;
+    private generation;
+    private lastFrame;
+    private reset;
+    /** Tokenize `text` with `resolved`, resuming from the cached grammar state when one exists. */
+    private tokenize;
+    /**
+     * Tokenize one update as a delta for a retained renderer.
+     * @param code - the fence text accumulated so far.
+     * @param lang - the language hint.
+     * @returns Newly completed lines plus the current tail, or `undefined` for the plain arm.
+     */
+    updateFrame(code: string, lang: string | undefined): StreamingHighlightFrame | undefined;
+    /**
+     * Tokenize the fence's current text into per-line highlighted runs;
+     * `undefined` means the caller renders its plain fallback. Idempotent per
+     * (`code`, `lang`) input — repeated calls return the identical result array —
+     * and a retained line keeps its span-array identity across growing calls, so
+     * a React caller can reuse cached line elements. A lazy grammar not yet
+     * loaded returns `undefined` and loads in the background exactly as
+     * {@link highlightToHtml} does; the next call after it registers highlights.
+     * @param code - the fence text accumulated so far (display-trimmed, no synthetic trailing newline).
+     * @param lang - the language hint (a markdown fence info string).
+     * @returns one entry per line of `code` (each an array of runs), or `undefined` for unknown or not-yet-loaded languages.
+     */
+    update(code: string, lang: string | undefined): readonly HighlightSpan[][] | undefined;
+}
+/** One retained-renderer update from {@link StreamingHighlightSession.updateFrame}. */
+export interface StreamingHighlightFrame {
+    /** Changes whenever prior completed lines must be discarded. */
+    readonly generation: number;
+    /** Completed lines added since the preceding frame in this generation. */
+    readonly appended: readonly HighlightSpan[][];
+    /** The still-growing final line or lines, replaced by the next frame. */
+    readonly tail: readonly HighlightSpan[][];
+}
+/**
+ * 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
+ * markup font-style bits the theme lets through (bold/italic/underline in
+ * markdown scopes) are dropped — the line-numbered file view renders
+ * color-only runs. 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/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/markdown/incremental.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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, or a list
+ * continuing after a blank line) — 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. A final unclosed top-level
+ * fence cannot freeze as a block, so its completed content lines use a second
+ * frontier: only the last completed line and current partial line return
+ * through the caller's grammar. Each source region is therefore parsed a
+ * bounded number of times over the stream instead of once per chunk.
+ *
+ * The block freeze boundary comes from the parser's own `position` offsets.
+ * 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. Fence scanning only recognizes a
+ * parser-confirmed code node and closing delimiter; ambiguous input returns to
+ * the normal tail parse.
+ *
+ * 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;
+    private openFence;
+    /** @param parse - Grammar shared with whatever renders the blocks, so boundaries agree. */
+    constructor(parse: (text: string) => Root);
+    /** Parse one unclosed-fence content slice through the caller's grammar. */
+    private fenceValue;
+    /** Recognize the parsed tail's final unclosed fence and prepare its incremental content frontier. */
+    private openFenceState;
+    /** Extend a recognized unclosed fence without parsing its completed content prefix again. */
+    private updateOpenFence;
+    /**
+     * 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/node_modules/@deepseek-ai/dsh-client-ui-primitives/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/node_modules/@deepseek-ai/dsh-client-ui-primitives/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/node_modules/@deepseek-ai/dsh-client-ui-primitives/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/node_modules/@deepseek-ai/dsh-client-ui-primitives/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

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/markdown/render.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Direct mdast→React markdown renderer. Replaces the react-markdown /
+ * remark-rehype pipeline with one switch over parsed nodes so streaming can
+ * cache frozen blocks as React elements; the rendered DOM is pinned
+ * byte-for-byte by `tests/fixtures/markdown-dom` and must not drift.
+ *
+ * External link and image destinations pass a protocol allowlist; settled
+ * local file links use an explicit owner callback. Images additionally require
+ * absolute HTTP(S), raw HTML renders as literal text (no HTML enters the
+ * DOM), and KaTeX runs without trusted commands. Fragment-anchor URLs fail
+ * the allowlist, so footnote references and back-references render as plain
+ * text rather than in-page links.
+ *
+ * Merge-extensible node unions fall through the documented default (render
+ * nothing) rather than ending in assertNever: grammars registered elsewhere
+ * may add node types this renderer has no mapping for.
+ */
+import type { ReactNode } from 'react';
+import type * as Md from 'mdast';
+import type { PositionedBlock } from './incremental.ts';
+/** Copy-button labels forwarded to fence CodeBlocks (this package is cordis-free, so copy arrives via props). */
+export interface MarkdownCodeLabels {
+    /** Copy-button idle label. */
+    copyLabel: string;
+    /** Copy-button label during the post-copy confirmation window. */
+    copiedLabel: string;
+}
+/** Localized chrome for a Markdown document. */
+export interface MarkdownLabels {
+    code: MarkdownCodeLabels;
+    footnotes: string;
+}
+/** Link/image reference targets collected from a document (first definition per identifier wins, as in CommonMark). */
+export interface ReferenceTargets {
+    /** Link/image definitions keyed by upper-cased identifier. */
+    definitions: Map<string, Md.Definition>;
+    /** Footnote definitions keyed by upper-cased identifier. */
+    footnotes: Map<string, Md.FootnoteDefinition>;
+}
+/**
+ * Create an empty {@link ReferenceTargets}.
+ * @returns Fresh empty maps.
+ */
+export declare function createReferenceTargets(): ReferenceTargets;
+/**
+ * Record every definition and footnote definition under `nodes` into
+ * `targets`, depth-first, keeping the first definition per identifier.
+ * @param nodes - Subtrees to walk (top-level blocks or any nested children).
+ * @param targets - Accumulator, typically shared across incremental segments.
+ */
+export declare function collectReferenceTargets(nodes: readonly Md.RootContent[], targets: ReferenceTargets): void;
+/**
+ * Local-path image vocabulary for image destinations: the owner maps an
+ * authored destination that fails the remote-URL allowlist (an absolute local
+ * file path, for example) to a displayable URL it can vouch for. Absent
+ * wherever no such vocabulary exists, authored local destinations keep their
+ * documented fallback (the image's alt text). Rewritten destinations must be
+ * absolute; the renderer re-checks their protocol before emitting them.
+ */
+export interface MarkdownPathImages {
+    /**
+     * Resolve one authored image destination.
+     * @param value - The destination exactly as the markdown author wrote it.
+     * @returns A displayable absolute URL, or undefined when the destination
+     * names no displayable image — it then stays inert alt text.
+     */
+    resolve(value: string): string | undefined;
+}
+/**
+ * File-mention affordance for inline code: the owner resolves an authored
+ * token to the file it names, using its own vocabulary of real files — the
+ * renderer never guesses at what looks like a path.
+ */
+export interface MarkdownFileMentions {
+    /**
+     * Resolve one inline-code token.
+     * @param value - The authored token, exactly as written.
+     * @returns The opener with its accessible label and full-path title, or
+     * undefined when the token names no known file — it then stays inert code.
+     */
+    resolve(value: string): {
+        open: () => void;
+        label: string;
+        title: string;
+    } | undefined;
+}
+/**
+ * One render pass's state: immutable options and targets plus the footnote
+ * numbering accumulated in document order while references render.
+ */
+export interface MarkdownRenderContext {
+    /** Streaming arm: fences highlight incrementally as they grow; TeX (including ```math fences) stays literal until the settled pass. */
+    readonly streaming: boolean;
+    /** Localized fence copy-button labels. */
+    readonly labels: MarkdownLabels;
+    /** Inside a blockquote's children: tables there always fill the quote's width. */
+    readonly inBlockquote?: boolean;
+    /** Inline-code file mentions; absent wherever no opener vocabulary exists. */
+    readonly fileMentions: MarkdownFileMentions | undefined;
+    /** Local-path image vocabulary; absent wherever no rewriting owner exists. */
+    readonly pathImages: MarkdownPathImages | undefined;
+    /** Inside an anchor's children: interactive mentions must not nest there. */
+    readonly inLink?: boolean;
+    /** Reference targets visible to this pass. */
+    readonly targets: ReferenceTargets;
+    /** Footnote identifiers in first-reference order; a footnote's number is its 1-based index here. */
+    readonly footnoteOrder: string[];
+    /** References rendered per identifier; drives the section's back-reference count. */
+    readonly footnoteCounts: Map<string, number>;
+}
+/**
+ * Render top-level blocks. Nodes that render nothing (definitions, unmapped
+ * types) are dropped rather than kept as null placeholders, matching the
+ * replaced pipeline's child lists so separator newlines land identically.
+ * @param blocks - Blocks with their stream-stable render keys.
+ * @param context - The pass state; footnote numbering mutates in document order.
+ * @returns One React node per rendered block.
+ */
+export declare function renderBlocks(blocks: readonly PositionedBlock[], context: MarkdownRenderContext): ReactNode[];
+/**
+ * Interleave the newline text nodes the replaced pipeline emitted between
+ * block-level children. They are invisible between elements but coalesce
+ * into adjacent literal raw-HTML text, where the DOM parity fixtures pin
+ * them.
+ * @param elements - Rendered block children with empty renders already dropped.
+ * @param edges - Also emit the leading and trailing newline (hast's loose wrap).
+ * @returns The interleaved children.
+ */
+export declare function wrapBlockChildren(elements: readonly ReactNode[], edges: boolean): ReactNode[];
+/**
+ * Render the trailing footnote section for every footnote referenced during
+ * the pass, in first-reference order, with one plain-text back-reference
+ * marker per rendered reference.
+ * @param context - The pass state after all blocks rendered.
+ * @returns The section, or null when no referenced footnote has a definition.
+ */
+export declare function renderFootnoteSection(context: MarkdownRenderContext): ReactNode | null;
+//# sourceMappingURL=render.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/markdown/useViewportHighlighting.d.ts

@@ -0,0 +1,11 @@
+import type { RefObject } from 'react';
+/**
+ * Activate one supported code surface when it first intersects the viewport.
+ * Activation lasts for the component lifetime; browsers without
+ * IntersectionObserver activate immediately.
+ * @param target - Code surface whose plain rendering reserves its geometry.
+ * @param lang - Optional language hint.
+ * @returns Whether this component may build highlighted output.
+ */
+export declare function useViewportHighlighting(target: RefObject<Element>, lang: string | undefined): boolean;
+//# sourceMappingURL=useViewportHighlighting.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/pointer-grace.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Grace before a pointer-dismissed popup closes. Covers the anchor->popup gap
+ * (8px for HoverCard, 4px for Menu) at a hand's travel speed without leaving a
+ * popup lingering once the pointer has genuinely moved on.
+ */
+export declare const POINTER_GRACE_MS = 200;
+/** Cancelable delayed close for a pointer-dismissed popup. */
+export interface PointerGrace {
+    /** Schedule the close {@link POINTER_GRACE_MS} from now, replacing any pending one. */
+    arm: () => void;
+    /** Abort a pending close (the pointer came back). */
+    cancel: () => void;
+}
+/**
+ * Delay a pointer-dismissed popup's close so the pointer can cross the gap
+ * between anchor and popup. A pending close is dropped on unmount.
+ * @param close - runs when the grace elapses with no re-entry; read at fire
+ * time, so callers may pass a fresh closure each render.
+ * @returns the {@link PointerGrace} handle.
+ */
+export declare function usePointerGrace(close: () => void): PointerGrace;
+//# sourceMappingURL=pointer-grace.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/rank-by-name.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared ranking for `/` menu candidates: the query must be a
+ * case-insensitive ordered subsequence of the candidate name or, when the
+ * candidate carries one, of its display label (a localized title). Prefix
+ * hits rank first, then the strongest alignment score over either key, then
+ * the source order of the input. Decision record:
+ * .agents/notes/archived/feature/2026-08-04-web-slash-command-fuzzy-discovery.md
+ */
+/**
+ * Rank named items by a menu query.
+ * @param items - candidates in source order (a host catalog, then client
+ * contributions); an item's optional `label` is a second search key beside
+ * its name.
+ * @param rawQuery - the text typed after the trigger, matched case-insensitively.
+ * @returns the matching items: prefix hits first, then by alignment score,
+ * then in source order. The input list itself for an empty query.
+ */
+export declare function rankByName<T extends {
+    readonly name: string;
+    readonly label?: string;
+}>(items: readonly T[], rawQuery: string): readonly T[];
+//# sourceMappingURL=rank-by-name.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/relative-time.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compact relative-time bucketing shared by every surface that dates a
+ * session. Bucketing is here so two surfaces naming the same session agree;
+ * the words stay in each plugin's own dictionary, per locale-owned copy.
+ *
+ * @module @deepseek-ai/dsh-client-ui-primitives/relative-time
+ */
+/** Relative-time bucket of a dated row's trailing label. */
+export type RelativeTimeUnit = 'now' | 'minutes' | 'hours' | 'days' | 'months' | 'years';
+/** Structured relative time: the bucket plus its magnitude (0 for 'now'). */
+export interface RelativeTime {
+    unit: RelativeTimeUnit;
+    n: number;
+}
+/**
+ * Compact relative time, as a structured bucket the renderer localizes
+ * ("now"/"5min"/"3h"/"2d"/"4mo"/"1y" in en).
+ * @param at - epoch ms of the dated moment.
+ * @param now - current epoch ms (injected for pure rendering).
+ * @returns the row's trailing time bucket and magnitude.
+ */
+export declare function relativeTime(at: number, now: number): RelativeTime;
+//# sourceMappingURL=relative-time.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/use-copy-feedback.d.ts

@@ -0,0 +1,14 @@
+/** The copy-feedback hook's return: the transient flag and the copy handler. */
+export interface CopyFeedback {
+    /** True for {@link COPIED_FEEDBACK_MS} after a successful write; render the success label off it. */
+    copied: boolean;
+    /** Copy the hook's text; no-op while `copied` is still true, silent on a refused write. */
+    onCopy: () => void;
+}
+/**
+ * Copy `text` to the clipboard with one-second success feedback.
+ * @param text - the text to write on copy.
+ * @returns the `copied` flag and the `onCopy` handler.
+ */
+export declare function useCopyFeedback(text: string): CopyFeedback;
+//# sourceMappingURL=use-copy-feedback.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/useAnchoredMaxHeight.d.ts

@@ -0,0 +1,11 @@
+import type { RefObject } from 'react';
+/**
+ * Clamp a bottom-anchored overlay's max-height to the viewport.
+ * @param ref - the overlay element; a null current (overlay closed) skips measuring.
+ * @param cap - design max-height in px (the clamp never exceeds it).
+ * @param signal - re-measure trigger: pass the overlay's render state so anchor
+ *   moves (composer growth) re-fit; resize/scroll re-fit while mounted.
+ * @returns the max-height to apply inline, in px.
+ */
+export declare function useAnchoredMaxHeight(ref: RefObject<HTMLElement>, cap: number, signal: unknown): number;
+//# sourceMappingURL=useAnchoredMaxHeight.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/useAnchoredPosition.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Keep a fixed-position floating element anchored to a trigger.
+ *
+ * A portaled panel is positioned from its anchor's viewport rect, which stops
+ * being true the moment anything scrolls or the window resizes. This owns that
+ * one concern: measure the anchor, offset the panel below or above it, clamp
+ * the result inside the viewport, and re-run on scroll (capture phase, so
+ * scrollers nested inside the page are caught too), on resize, and on the
+ * panel's own size changes while the element is open.
+ * @module @deepseek-ai/dsh-client-ui-primitives/useAnchoredPosition
+ */
+import { type CSSProperties, type RefObject } from 'react';
+/** Inputs for {@link useAnchoredPosition}. */
+export interface AnchoredPositionOptions {
+    /** Whether the floating element is mounted and should track its anchor. */
+    open: boolean;
+    /** The element the panel is placed from. */
+    anchorRef: RefObject<HTMLElement | null>;
+    /** The floating element, measured so the clamp uses real dimensions. */
+    panelRef: RefObject<HTMLElement | null>;
+    /** Which anchor edge the panel hangs from: below it (`bottom`, the default) or above it (`top`). */
+    side?: 'top' | 'bottom';
+    /** Distance kept between the anchor edge named by `side` and the panel. */
+    gap: number;
+    /** Distance kept between the panel and each viewport edge. */
+    margin: number;
+}
+/**
+ * Track an anchor and return the panel's fixed coordinates.
+ * @param options - the open state, the two refs, the placement side, and the gap/margin distances.
+ * @returns `left`/`top` for the panel, or `null` before the first measurement.
+ */
+export declare function useAnchoredPosition(options: AnchoredPositionOptions): CSSProperties | null;
+//# sourceMappingURL=useAnchoredPosition.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/useDismissOnOutsidePointer.d.ts

@@ -0,0 +1,11 @@
+import type { RefObject } from 'react';
+/**
+ * Close an open popover when a pointerdown lands outside its root element.
+ * @param root - element containing both the trigger and the open surface.
+ * @param open - whether the surface is showing; false detaches the listener.
+ * @param setOpen - state setter invoked with false on an outside pointerdown.
+ * @param portal - surface portaled outside the root (a `document.body` dialog)
+ * that also counts as inside; omit when the root contains the whole popover.
+ */
+export declare function useDismissOnOutsidePointer(root: RefObject<HTMLElement | null>, open: boolean, setOpen: (open: boolean) => void, portal?: RefObject<HTMLElement | null>): void;
+//# sourceMappingURL=useDismissOnOutsidePointer.d.ts.map

package/node_modules/@deepseek-ai/dsh-client-ui-primitives/lib/types/user-text.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Display projection of reference forms in sent user text (bubble and queue
+ * rows). The logged model text remains the single truth; this is presentation
+ * only, and every part renders inline so a single-line message never breaks
+ * across lines. Four decoration sources, by precedence: the wire session form
+ * `@[label](dsh-session:...)` folds to its label; exact session labels
+ * supplied by an adjacent recall decorate their bare `@label` mention; plain
+ * `@name` word-boundary tokens decorate by shape alone; and a plain `/name`
+ * token decorates only when the caller names it — a skill the host actually
+ * loaded for that message (ui-chat reads the step's `skill-invocation`
+ * injections) or the command a command-input bubble echoes — so `/123` or a
+ * stray `/word` stays plain text. A `/name` token is whitespace-bounded like
+ * the host skill gesture (`dsh-tool-skill`): it ends at whitespace or the
+ * text end, so slash paths (`/nfs-hg/xxx`, `/plan.md`) and punctuation-glued
+ * tokens (`/plan。`) stay plain even for a loaded name.
+ */
+import type { ReactNode } from 'react';
+/** Optional navigation supplied by consumers that can preview references. */
+export interface UserTextReferences {
+    /** Open a file path decoded from an `@` mention. */
+    openFile: (path: string) => void;
+    /** Open the source of a skill loaded for this message. */
+    openSkill: (name: string) => void;
+}
+/**
+ * Split one sent text into inline plain runs and reference chips.
+ * @param text - the logged model text of the message or queue row.
+ * @param sessionLabels - exact session mention labels associated by an adjacent recall.
+ * @param slashNames - names a `/name` token may decorate as: the skills the
+ * host loaded for this message, or the command a command bubble echoes
+ * (unsent queue rows pass none).
+ * @param slashKind - the chip kind those tokens render as.
+ * @param references - optional file and skill preview actions; session and command tokens stay labels.
+ * @returns inline nodes covering the whole text.
+ */
+export declare function projectUserText(text: string, sessionLabels: readonly string[], slashNames?: readonly string[], slashKind?: 'skill' | 'command', references?: UserTextReferences): ReactNode;
+//# sourceMappingURL=user-text.d.ts.map