@yadsh/dsh-qa-surface 0.7.4 → 0.9.0

package/lib/types/client/components/QaSourcesPanel.d.ts

@@ -1,8 +1,6 @@
 import type { QaSource, QaTurnSources, ResolvedQaSurfaceConfig } from "../../types.js";
 import type { QaBoundSourceApi } from "../types.js";
-export declare function SourceIcon({ kind }: {
-    readonly kind: QaSource["kind"];
-}): import("react/jsx-runtime").JSX.Element;
+export { SourceIcon } from "./source-icon.js";
 export interface QaSourcesPanelProps {
     readonly sources: readonly QaSource[];
     readonly complete: boolean;

package/lib/types/client/components/source-icon.d.ts

@@ -0,0 +1,12 @@
+import type { QaSource } from "../../types.js";
+/**
+ * Leaf source-kind vocabulary: the icon and the group labels a kind wears.
+ * Kept free of component imports so the markdown renderer's chips can share
+ * it without pulling the sources panel (and its markdown dependency) into
+ * every inline parse.
+ */
+export declare const KIND_LABELS: Readonly<Record<QaSource["kind"], string>>;
+export declare function SourceIcon({ kind }: {
+    readonly kind: QaSource["kind"];
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=source-icon.d.ts.map

package/lib/types/client/components/use-now.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A per-second `Date.now()` that runs only while `active` (and re-syncs the
+ * instant it turns on). The thinking phrase and the running work group read
+ * the same clock through this hook, so the surface never stacks duplicate
+ * second intervals for one turn.
+ */
+export declare function useNow(active: boolean): number;
+//# sourceMappingURL=use-now.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { SessionSummary } from "@deepseek-ai/dsh-api-session-controller/client";
+/**
+ * Whether one session-list entry is a delegated child — a subagent's session —
+ * rather than a chat.
+ *
+ * A delegated run is an implementation detail of a single answer: the Host
+ * refuses to attest it, its sources reach the parent chat through the
+ * provenance inheritance flow, and it has no owner. The host list the surface
+ * already follows carries both marks (`origin` and `parentId`), so every
+ * projection that talks about chats asks this one question instead of
+ * re-deriving it — and a chat row, a chat count and a claim batch can never
+ * disagree about what a chat is.
+ */
+export declare function isDelegatedSession(summary: Pick<SessionSummary, "origin" | "parentId"> | undefined): boolean;
+//# sourceMappingURL=lineage.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+/**
+ * One fenced code block: the language banner, a copy button, and the code
+ * itself. Highlighting is our own scanner (see `highlight.ts`) — the fence is
+ * memoized on its source and info string, so a streaming append re-tokenizes
+ * only the fence that grew.
+ */
+export declare const CodeBlock: import("react").MemoExoticComponent<({ code, lang, }: {
+    readonly code: string;
+    readonly lang?: string;
+}) => import("react/jsx-runtime").JSX.Element>;
+/** The globe an external link wears, drawn like the surface's other icons. */
+export declare function LinkGlyph(): ReactNode;
+//# sourceMappingURL=CodeBlock.d.ts.map

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

@@ -0,0 +1,74 @@
+/**
+ * GFM block grammar for the chat renderer: the container and leaf blocks the
+ * assistant's answers actually use, parsed here and handed to `render.tsx` as
+ * plain data. Text inside a leaf block stays raw Markdown — `parseInline`
+ * resolves it at render time — so one block pass feeds every inline consumer.
+ *
+ * The grammar is deliberately a subset of CommonMark: nested containers and
+ * lazy continuation are supported, while the pathological corners (HTML
+ * blocks, setext inside lists, link reference definitions spanning lines) stay
+ * out. Raw HTML never becomes a block: a tag line is a paragraph whose inline
+ * pass leaves the tag as literal text.
+ */
+/** `#`-through-`######` heading levels. */
+export type HeadingDepth = 1 | 2 | 3 | 4 | 5 | 6;
+/** Column alignment carried by a table's delimiter row. */
+export type TableAlign = "left" | "center" | "right";
+/** One list item: its own blocks plus the checkbox a task item declares. */
+export interface MarkdownListItem {
+    readonly blocks: readonly MarkdownBlock[];
+    readonly task: boolean;
+    readonly checked: boolean;
+}
+/** A block-level node; `text` fields hold raw inline Markdown. */
+export type MarkdownBlock = {
+    readonly kind: "paragraph";
+    readonly text: string;
+} | {
+    readonly kind: "heading";
+    readonly depth: HeadingDepth;
+    readonly text: string;
+} | {
+    readonly kind: "code";
+    readonly text: string;
+    readonly lang?: string;
+} | {
+    readonly kind: "quote";
+    readonly blocks: readonly MarkdownBlock[];
+} | {
+    readonly kind: "list";
+    readonly ordered: boolean;
+    readonly start: number;
+    readonly loose: boolean;
+    readonly items: readonly MarkdownListItem[];
+} | {
+    readonly kind: "table";
+    readonly align: readonly TableAlign[];
+    readonly head: readonly string[];
+    readonly rows: readonly (readonly string[])[];
+} | {
+    readonly kind: "rule";
+};
+/** A parsed document: its blocks plus the reference targets they resolve. */
+export interface ParsedMarkdown {
+    readonly blocks: readonly MarkdownBlock[];
+    /** Link/image definitions by upper-cased identifier. */
+    readonly definitions: ReadonlyMap<string, string>;
+}
+/** Split one table row into trimmed cells, honoring escaped pipes. */
+export declare function splitTableRow(line: string): string[];
+/**
+ * Parse a whole document.
+ * @param text - Markdown source with any line endings.
+ * @returns Blocks plus the definitions the inline pass resolves against.
+ */
+export declare function parseMarkdown(text: string): ParsedMarkdown;
+/**
+ * Parse the blocks of one container (document, quote, or list item).
+ * @param lines - Container lines, already de-indented by the caller.
+ * @param definitions - Document-wide definition accumulator.
+ * @param depth - Container nesting depth.
+ * @returns The container's blocks.
+ */
+export declare function parseBlocks(lines: readonly string[], definitions: Map<string, string>, depth: number): MarkdownBlock[];
+//# sourceMappingURL=blocks.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * The chat renderer's syntax highlighter: a small tokenizer over per-language
+ * keyword/comment/string tables, not a grammar engine. The original UI runs
+ * shiki; its grammar modules alone cost ~1.6 MB, which a self-contained plugin
+ * bundle cannot carry, so this scanner covers the shapes that carry meaning in
+ * an answer — comments, strings, numbers, keywords — and leaves the rest of the
+ * line in the foreground color. Colors come from the host theme's
+ * `--shiki-token-*` custom properties, so a fenced block here matches a fenced
+ * block in the assistant's own transcript in both light and dark themes.
+ *
+ * An unknown or absent language renders plain: never an error, never a guess.
+ */
+/** Token categories the stylesheet colors. */
+export type HighlightClass = "comment" | "string" | "keyword" | "number" | "constant" | "meta" | "tag" | "attr" | "key" | "insert" | "delete" | "hunk";
+/** One colored run of a code line. */
+export interface HighlightSpan {
+    readonly text: string;
+    readonly cls?: HighlightClass;
+}
+/** One code line as colored runs. */
+export type HighlightLine = readonly HighlightSpan[];
+/**
+ * Highlight one fenced block.
+ * @param code - The fence's source text.
+ * @param lang - The fence's info string.
+ * @returns One {@link HighlightLine} per source line.
+ */
+export declare function highlightLines(code: string, lang: string | undefined): HighlightLine[];
+//# sourceMappingURL=highlight.d.ts.map

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

@@ -0,0 +1,40 @@
+/**
+ * GFM inline grammar for the chat renderer: code spans, emphasis, links,
+ * images, autolinks, and the two line-break flavors. Emphasis follows the
+ * CommonMark intent (a closer must match its opener's delimiter run, `_` never
+ * opens inside a word) rather than the full delimiter-stack algorithm — the
+ * shapes this grammar cannot express are the pathological ones, and they
+ * degrade to literal text instead of mangling the sentence.
+ */
+/** One inline node; `children` nodes nest. */
+export type MarkdownInline = {
+    readonly kind: "text";
+    readonly value: string;
+} | {
+    readonly kind: "softbreak";
+} | {
+    readonly kind: "break";
+} | {
+    readonly kind: "code";
+    readonly value: string;
+} | {
+    readonly kind: "strong" | "em" | "del";
+    readonly children: readonly MarkdownInline[];
+} | {
+    readonly kind: "link";
+    readonly href: string;
+    readonly children: readonly MarkdownInline[];
+} | {
+    readonly kind: "image";
+    readonly src: string;
+    readonly alt: string;
+};
+/**
+ * Parse the inline content of one leaf block.
+ * @param text - Raw inline Markdown, newlines included.
+ * @param definitions - Link/image definitions collected by the block pass.
+ * @param depth - Inline nesting depth.
+ * @returns The inline nodes in document order.
+ */
+export declare function parseInline(text: string, definitions: ReadonlyMap<string, string>, depth?: number): MarkdownInline[];
+//# sourceMappingURL=inline.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+import { type MarkdownSourceContext } from "./source-chip.js";
+/**
+ * Render markdown source as semantic React elements. Raw HTML never enters the
+ * DOM (a tag is literal text), link and image destinations pass a protocol
+ * allowlist, and a source the owning message knows about becomes a chip
+ * instead of a plain link or code token.
+ * @param text - Assistant-authored markdown.
+ * @param context - Source resolution handed down by the owning message.
+ * @returns The document's blocks.
+ */
+export declare function renderMarkdown(text: string, context: MarkdownSourceContext): ReactNode[];
+//# sourceMappingURL=render.d.ts.map

package/lib/types/client/markdown/source-chip.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from "react";
+import type { QaSource } from "../../types.js";
+import { type QaSourceRefs } from "../components/source-refs.js";
+/** Inline source awareness handed down from the owning assistant message. */
+export interface MarkdownSourceContext {
+    readonly refs?: QaSourceRefs;
+    /** Open a path-backed source in the sources drawer's detail view. */
+    readonly onSourceOpen?: (source: QaSource) => void;
+}
+/**
+ * One inline source footnote: a pill over the matched link or path with a
+ * hover/focus preview card (title, target, snippet). A URL-backed source is
+ * an anchor that opens right away; a path-backed one is a button whose click
+ * the owner routes to the sources drawer. The hover card stays out of the
+ * chip's accessible name and rides along as its description instead.
+ */
+export declare function SourceChip({ source, label, href, onOpen, }: {
+    readonly source: QaSource;
+    readonly label: string;
+    readonly href?: string;
+    readonly onOpen?: (source: QaSource) => void;
+}): ReactNode;
+/**
+ * The chip a path-backed inline-code token earns, or undefined when the token
+ * names no known source. A URL-backed token is a chip that opens right away.
+ */
+export declare function codeChip(value: string, context: MarkdownSourceContext): ReactNode | undefined;
+/** The chip a matched markdown link earns, or undefined when it matches none. */
+export declare function linkChip(href: string, label: string, context: MarkdownSourceContext): ReactNode | undefined;
+/** http(s)/mailto destinations only; images are narrowed further to http(s). */
+export declare function safeHref(value: string): string | undefined;
+//# sourceMappingURL=source-chip.d.ts.map

package/lib/types/client/markdown/use-transient-flag.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A boolean that turns on for a fixed window and drops back off — the
+ * "Скопировано" flash and its siblings. The pending timer lives in a ref and
+ * is cleared by the unmount cleanup, so a pulse fired right before the block
+ * leaves the DOM never schedules a state update on it, and re-pulsing restarts
+ * the window instead of stacking timers.
+ */
+export declare function useTransientFlag(windowMs: number): {
+    readonly on: boolean;
+    readonly pulse: () => void;
+};
+//# sourceMappingURL=use-transient-flag.d.ts.map

package/lib/types/client/project-session-state.d.ts

@@ -1,6 +1,6 @@
 import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
 import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
-import type { QaPendingApproval, QaPendingQuestion, QaSessionState, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaPendingApproval, QaPendingQuestion, QaSessionState, QaSlashView, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
 /** Everything the bound-chat projection reads; the computation is pure. */
 export interface QaBoundProjectionInput {
     readonly connected: boolean;
@@ -23,6 +23,8 @@ export interface QaBoundProjectionInput {
     readonly admissionPending: boolean;
     readonly chatsRevision: number;
     readonly viewingSubagent: QaSubagentView | null;
+    /** Slash catalog state of this chat; the controller owns its lifetime. */
+    readonly slash: QaSlashView;
     readonly config: ResolvedQaSurfaceConfig;
     /**
      * The chat's subagent display names keyed by session id, read from the

package/lib/types/client/prompt-content.d.ts

@@ -1,5 +1,5 @@
 import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
-import type { QaAttachmentDraft, QaFileDraft } from "../types.js";
+import type { QaAttachmentDraft, QaFileDraft, QaSlashSubmitAttachment } from "../types.js";
 import type { QaFileUpload, QaPromptContent } from "./types.js";
 /**
  * Stage every pending file on the Host and collect the receipts the prompt
@@ -26,5 +26,13 @@ export declare function stageQaFiles(service: QaFileUpload | undefined, session:
  * staging failed elsewhere) degrades to an empty receipt rather than
  * dropping the attachment.
  */
+/**
+ * The same two shapes for a human command, which admits attachments through
+ * the shared store rather than through the prompt: an image rides encoded, a
+ * file rides the receipt its staging minted. An attachment whose staging
+ * failed is dropped instead of being sent as an empty receipt — the command
+ * would otherwise read a handle that resolves to nothing.
+ */
+export declare function buildQaSlashAttachments(attachments: readonly QaAttachmentDraft[], receipts: ReadonlyMap<string, string>): readonly QaSlashSubmitAttachment[];
 export declare function buildQaPromptContent(prompt: string, attachments: readonly QaAttachmentDraft[], receipts: ReadonlyMap<string, string>): QaPromptContent;
 //# sourceMappingURL=prompt-content.d.ts.map

package/lib/types/client/role/RoleSelector.d.ts

@@ -8,7 +8,17 @@ export interface QaRoleSelectorProps {
 }
 /** Visible only when the account can actually choose between profiles. */
 export declare function QaRoleSelector(props: QaRoleSelectorProps): import("react/jsx-runtime").JSX.Element | null;
-export declare function QaAdminPreviewBanner({ role }: {
+/**
+ * The banner that keeps a preview from being mistaken for an ordinary chat.
+ *
+ * It carries the way out as well: while previewing, the header's role selector
+ * is hidden — the previewed profile need not be one the account holds — so
+ * without a control here the only exit was the browser's Back button, and a new
+ * chat meanwhile ran as the previewed profile instead of the account's default.
+ * @param props - the previewed role's name, and how to leave the preview.
+ */
+export declare function QaAdminPreviewBanner(props: {
     readonly role: string;
+    readonly onExit?: () => void;
 }): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=RoleSelector.d.ts.map

package/lib/types/client/role/preview.d.ts

@@ -0,0 +1,109 @@
+import type { QaSubrole } from "../../types.js";
+/**
+ * The administrator preview mode, as a property of the history entry.
+ *
+ * "Preview as role" navigates to the chat route carrying a marker in the
+ * history state. Deriving the mode from the entry — instead of latching it in
+ * component state — is what lets the browser's own Back button leave the
+ * preview, and what keeps a preview from outliving its entry: while the mode
+ * was latched, every later new chat in that browser tab was created as a
+ * preview of the previewed profile, silently ignoring the account's default
+ * profile, with the role selector hidden and only a corner banner to say so.
+ */
+/** One preview in force: the role and the name it was previewed under. */
+export interface QaAdminPreview {
+    readonly roleId: string;
+    readonly name: string;
+}
+interface PreviewState {
+    readonly qaPreview: string;
+    readonly qaPreviewName: string;
+}
+/** The history state a "Preview as role" navigation carries. */
+export declare function previewEntryState(role: Pick<QaSubrole, "id" | "name">): PreviewState;
+/**
+ * The preview one history entry asks for, or undefined for an ordinary entry.
+ *
+ * Home of an older Host or of a cleared entry carries no marker at all, and a
+ * marker whose role id cannot be read is ignored rather than guessed: the name
+ * is cosmetic, so an entry written before names travelled with the marker
+ * still previews, under its role id.
+ */
+export declare function readPreviewEntry(state: unknown): QaAdminPreview | undefined;
+export type QaPreviewTransition = {
+    readonly kind: "enter";
+    readonly preview: QaAdminPreview;
+} | {
+    readonly kind: "leave";
+} | {
+    readonly kind: "keep";
+};
+/**
+ * What the surface should do with the preview mode for one history entry.
+ *
+ * Only an administrator can preview, so an entry that asks for one while an
+ * ordinary account is signed in leaves the mode instead of entering it — the
+ * marker survives in the browser's history across a sign-out, and latching it
+ * again would hand the next account a chat under a profile it was never
+ * assigned.
+ * @param input - the entry's state, the preview in force, and who is signed in.
+ * @returns enter, leave, or keep, so the caller only writes state it must.
+ */
+export declare function planPreviewTransition(input: {
+    readonly state: unknown;
+    readonly preview: QaAdminPreview | null;
+    readonly isAdmin: boolean;
+}): QaPreviewTransition;
+/** The slice of the browser the preview needs; a test injects its own. */
+export interface QaPreviewBrowser {
+    readonly state: unknown;
+    pushState(data: unknown, unused: string, url?: string | null): void;
+    replaceState(data: unknown, unused: string, url?: string | null): void;
+    /** Subscribe to browser navigation; returns the unsubscribe. */
+    onPopState(listener: () => void): () => void;
+}
+export interface QaAdminPreviewOptions {
+    /** Only an administrator may preview; anyone else leaves the mode. */
+    readonly isAdmin: boolean;
+    /** The account's own default profile, restored when a preview ends. */
+    readonly fallbackSubrole: string | null;
+    /** The chat route a preview navigation returns to. */
+    readonly previewUrl: string;
+    /** Called with the profile the next chat must use; null when none is known. */
+    readonly onSelect: (roleId: string | null) => void;
+    /**
+     * Re-checked on every browser navigation AND whenever this changes: an
+     * in-app navigation to the chat route arrives without a `popstate` event.
+     */
+    readonly routeKey: string;
+    readonly target?: QaPreviewBrowser;
+}
+export interface QaAdminPreviewMode {
+    /** The preview in force right now, if any. */
+    readonly preview: QaAdminPreview | null;
+    /** Enter the preview of one role, as the administration console asks. */
+    readonly enter: (role: Pick<QaSubrole, "id" | "name">) => void;
+    /**
+     * End the mode because the chat on screen is not a preview, leaving the
+     * history entry alone: going Back to it is entering the preview again.
+     */
+    readonly clear: () => void;
+    /** End the mode for good, as the administrator asked from the banner. */
+    readonly leave: () => void;
+}
+/**
+ * The administrator preview mode of one browser tab.
+ *
+ * The mode is a property of the history entry, so entering and leaving it
+ * follows the browser: the console pushes an entry that carries the preview,
+ * every navigation back to an entry without one ends the mode, and only an
+ * administrator can hold it. The alternative — reading the marker once and
+ * latching it in component state — kept the mode alive for the whole tab, and
+ * since the role selector is hidden while previewing, later new chats silently
+ * ran as the previewed profile instead of the account's default one.
+ * @param options - who is signed in, the account default, and the history.
+ * @returns the preview in force plus the two explicit transitions.
+ */
+export declare function useQaAdminPreview(options: QaAdminPreviewOptions): QaAdminPreviewMode;
+export {};
+//# sourceMappingURL=preview.d.ts.map

package/lib/types/client/settings/sections/slash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Slash interface: the master switch, the two admission policies and the
+ * palette itself.
+ *
+ * The allow lists stay name-based, which is what the deployment config stores
+ * — an operator writes `generate-tkp`, never an id. They are plain lists
+ * rather than checkboxes over a discovered catalog because the two halves are
+ * discovered differently and only one of them can be enumerated here at all:
+ * skills are a registry lookup, while a command is only resolvable against a
+ * live chat's agent, so this card could not honestly offer a fixed list of
+ * command names to tick.
+ */
+import { type ConfigProps } from "./common.js";
+/** Master switch, per-kind admission policy and palette presentation. */
+export declare function SlashSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=slash.d.ts.map

package/lib/types/client/settings/sections.d.ts

@@ -19,6 +19,7 @@ export { EmbeddingSection } from "./sections/embedding.js";
 export { InterfaceSection } from "./sections/interface.js";
 export { LockdownSection } from "./sections/lockdown.js";
 export { SessionSection } from "./sections/session.js";
+export { SlashSection } from "./sections/slash.js";
 export { SourcesSection } from "./sections/sources.js";
 export { StatusSection } from "./sections/status.js";
 export type { StatusProps } from "./sections/status.js";

package/lib/types/client/slash/SlashPalette.d.ts

@@ -0,0 +1,24 @@
+import type { QaSlashCatalogEntry, QaSlashCommandSurface, QaSlashView } from "../../types.js";
+export interface QaSlashPaletteProps {
+    readonly rows: readonly QaSlashCatalogEntry[];
+    readonly activeId: string | null;
+    readonly state: QaSlashView["state"];
+    readonly error: string | null;
+    readonly commandSurface: QaSlashCommandSurface;
+    readonly showDescriptions: boolean;
+    readonly showKindBadge: boolean;
+    readonly idPrefix: string;
+    readonly onHover: (index: number) => void;
+    readonly onPick: (entry: QaSlashCatalogEntry) => void;
+}
+/**
+ * The palette itself: a listbox over rows the composer has already filtered
+ * and ranked. It owns no state — an empty list means "nothing matches", and
+ * the surface line says why when the catalog could not be read at all.
+ *
+ * Options are picked on `click` and never take focus (`onMouseDown` prevents
+ * the default) so the caret stays in the textarea: the keyboard keeps working
+ * straight after a click, and Escape still closes what the mouse opened.
+ */
+export declare const QaSlashPalette: import("react").MemoExoticComponent<(props: QaSlashPaletteProps) => import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=SlashPalette.d.ts.map

package/lib/types/client/slash/copy.d.ts

@@ -0,0 +1,30 @@
+import type { QaSlashCatalogEntry, QaSlashExecution } from "../../types.js";
+import type { QaSlashRoute } from "./slash-router.js";
+/**
+ * The user-facing copy of every slash decision. One module because these
+ * strings are the whole interface between a refusal and the person reading it:
+ * a refusal that does not say what to do next is indistinguishable from a bug.
+ */
+/** The refusal that predates the feature; unchanged, so nothing regresses. */
+export declare const SLASH_DISABLED_COPY = "\u041A\u043E\u043C\u0430\u043D\u0434\u044B \u0441\u043E \u0441\u043B\u0435\u0448\u0435\u043C \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B \u0432 \u0440\u0435\u0436\u0438\u043C\u0435 \u043F\u043E\u043C\u043E\u0449\u043D\u0438\u043A\u0430.";
+export declare function slashRefusalCopy(route: Extract<QaSlashRoute, {
+    kind: "unknown" | "ambiguous" | "unavailable";
+}>): string;
+/**
+ * A gesture inside an ordinary prompt that this deployment withholds. Stated
+ * as a fact about the deployment, not as a fault of the message, because the
+ * message itself is fine — it is one word of it that will not take effect.
+ */
+export declare function slashWithheldCopy(names: readonly string[]): string;
+export declare function slashExecuteFailureCopy(entry: QaSlashCatalogEntry): string;
+/** Copy for a refusal the Host decided, keyed by its reason. */
+export declare function slashHostRefusalCopy(refusal: Extract<QaSlashExecution, {
+    kind: "refused";
+}>): string;
+/**
+ * Attachments the chosen command refuses. Checked before dispatch so the
+ * composer keeps the draft and the files; the Host checks it again and stays
+ * the authority.
+ */
+export declare function slashAttachmentsCopy(entry: QaSlashCatalogEntry): string;
+//# sourceMappingURL=copy.d.ts.map

package/lib/types/client/slash/slash-router.d.ts

@@ -0,0 +1,67 @@
+import type { QaSlashCatalogEntry } from "../../types.js";
+/**
+ * Where one composer draft should go.
+ *
+ * The composer used to have a single path — `sendPrompt` — with a guard that
+ * turned every `/`-leading line away. That guard is now the `disabled` case
+ * below, and everything else is decided here, in one place, from the draft and
+ * the catalog alone. Keeping it pure is what makes the ambiguous, unknown and
+ * withheld cases testable without a browser or a Host.
+ */
+export type QaSlashRoute = 
+/**
+ * Ordinary text: the model gets it, exactly as before this feature. It may
+ * still name a skill this deployment withholds — the turn runs, and the
+ * surface says so rather than letting the user believe it took effect.
+ */
+{
+    readonly kind: "prompt";
+    readonly withheld?: readonly string[];
+}
+/** A user-invocable skill: the native prompt path carries the gesture. */
+ | {
+    readonly kind: "skill";
+    readonly entry: QaSlashCatalogEntry;
+}
+/** A human command: the Host's command runtime answers it, the model never sees it. */
+ | {
+    readonly kind: "command";
+    readonly entry: QaSlashCatalogEntry;
+}
+/** Nothing by that name is offered here. */
+ | {
+    readonly kind: "unknown";
+    readonly name: string;
+}
+/** A skill and a command share the name; only the user may choose. */
+ | {
+    readonly kind: "ambiguous";
+    readonly name: string;
+    readonly entries: readonly QaSlashCatalogEntry[];
+}
+/** The catalog could not be read, so no `/name` can be classified. */
+ | {
+    readonly kind: "unavailable";
+    readonly name: string;
+}
+/** The deployment runs with the slash interface off. */
+ | {
+    readonly kind: "disabled";
+};
+export interface ResolveSlashRouteInput {
+    readonly text: string;
+    readonly enabled: boolean;
+    readonly catalogReady: boolean;
+    readonly entries: readonly QaSlashCatalogEntry[];
+    /** User-invocable skills this deployment withholds from this chat. */
+    readonly deniedSkills: readonly string[];
+    /**
+     * The entry the user picked in the palette, while the draft still reads as
+     * its invocation. A picked identity outranks name resolution: when a skill
+     * and a command share a name, the user already answered the only question
+     * the router would otherwise have to guess at.
+     */
+    readonly picked?: string | null;
+}
+export declare function resolveSlashRoute(input: ResolveSlashRouteInput): QaSlashRoute;
+//# sourceMappingURL=slash-router.d.ts.map

package/lib/types/client/slash/useSlashNavigation.d.ts

@@ -0,0 +1,47 @@
+import type { QaSlashCatalogEntry, QaSlashView } from "../../types.js";
+export interface QaSlashNavigation {
+    /** True while the palette is on screen. */
+    readonly open: boolean;
+    readonly query: string;
+    /** The rows the palette renders, best match first. */
+    readonly rows: readonly QaSlashCatalogEntry[];
+    /** Index into `rows`; -1 when there is nothing to select. */
+    readonly active: number;
+    readonly activeId: string | null;
+    /** Move the selection by one row, wrapping at both ends. */
+    readonly move: (delta: number) => void;
+    /** Point the selection at one row, as a tap does. */
+    readonly hover: (index: number) => void;
+    /** Insert the active row's invocation into the draft. */
+    readonly pickActive: () => void;
+    /** Insert one row, as a click or a tap does. */
+    readonly pick: (entry: QaSlashCatalogEntry) => void;
+    /** Dismiss the palette for this draft. */
+    readonly dismiss: () => void;
+    /** The identity the user picked, while the draft still reads as its call. */
+    readonly picked: QaSlashCatalogEntry | undefined;
+}
+export interface UseSlashNavigationOptions {
+    readonly draft: string;
+    readonly slash: QaSlashView;
+    readonly maxVisible: number;
+    readonly fuzzySearch: boolean;
+    /** Set the draft to `text` and put the caret at its end. */
+    readonly setDraft: (text: string) => void;
+    /** Monotonic token; a change re-opens a palette the user had dismissed. */
+    readonly reopen: number;
+}
+/**
+ * Palette state for one composer draft.
+ *
+ * The palette is a pure function of the draft: it is open while the draft is
+ * `/` plus a name still being typed, and closes the moment the user types a
+ * space and starts writing arguments. Nothing has to be kept in sync — which
+ * is also why switching chats (the composer is keyed by chat and remounts)
+ * cannot leave a palette behind.
+ *
+ * Selection is one index over the filtered rows; the arrow keys, the mouse and
+ * the touch screen all move the same number.
+ */
+export declare function useSlashNavigation(options: UseSlashNavigationOptions): QaSlashNavigation;
+//# sourceMappingURL=useSlashNavigation.d.ts.map

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

@@ -1,4 +1,13 @@
 /** Every `--dsh-qa-*` custom property the root rule declares. */
 export declare const QA_BRAND_TOKEN_NAMES: readonly string[];
 export declare const QA_SURFACE_STYLES: string;
+/**
+ * Everything the QA overlay paints, as one sheet for one `<style>` tag.
+ *
+ * The shared audit components keep their own stylesheet in
+ * `@yadsh/dsh-audit-ui`; it is folded in here so the overlay is self-contained
+ * — the audit dialog must look right whether or not the audit plugin's own
+ * client bundle happens to have injected the same rules into the document.
+ */
+export declare const QA_OVERLAY_STYLES: string;
 //# sourceMappingURL=styles.d.ts.map