@yadsh/dsh-qa-surface 0.1.1 → 0.3.0

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

@@ -0,0 +1,25 @@
+import type { SessionSummary } from "@deepseek-ai/dsh-api-session-controller/client";
+/** One row of the agents panel: a subagent session of the open chat. */
+export interface QaSubagentRow {
+    readonly id: string;
+    readonly title: string;
+    readonly running: boolean;
+    readonly completed: boolean;
+    readonly meta: string;
+}
+/**
+ * Direct subagent children of the open chat, running first. Reads the host
+ * session list's lineage (parentId + origin), so no extra subscription beyond
+ * the list the surface already follows.
+ */
+export declare function collectSubagents(byId: Readonly<Record<string, SessionSummary>>, rootId: string | null, now?: number): readonly QaSubagentRow[];
+export interface QaAgentsDrawerProps {
+    readonly agents: readonly QaSubagentRow[];
+    /** The subagent currently watched, if any. */
+    readonly activeId: string | null;
+    readonly onView: (id: string, title: string) => void;
+    readonly onClose: () => void;
+}
+/** Right-hand panel listing the chat's subagents. */
+export declare function QaAgentsDrawer({ agents, activeId, onView, onClose, }: QaAgentsDrawerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaAgentsDrawer.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { QaAccountsController, QaAccountsSnapshot } from "../QaAccountsController.js";
+export interface QaAuthGateProps {
+    readonly accounts: QaAccountsController;
+    readonly snapshot: QaAccountsSnapshot;
+    readonly title: string;
+    readonly logoUrl: string | null;
+    readonly allowRegistration: boolean;
+}
+/**
+ * The full-frame login/registration card shown instead of the chat while the
+ * deployment has accounts enabled and the browser holds no valid identity.
+ * Errors are the Host's coarse codes rendered as audience-safe copy.
+ */
+export declare function QaAuthGate(props: QaAuthGateProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaAuthGate.d.ts.map

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

@@ -0,0 +1,21 @@
+export declare const QA_VERSION: string;
+export interface QaChangelogEntry {
+    readonly version: string;
+    readonly date: string;
+    readonly sections: readonly {
+        readonly title: string;
+        readonly items: readonly string[];
+    }[];
+}
+export declare const QA_CHANGELOG: readonly QaChangelogEntry[];
+/** Props of the {@link QaChangelogModal} dialog. */
+export interface QaChangelogModalProps {
+    readonly open: boolean;
+    readonly onClose: () => void;
+}
+/**
+ * The version/changelog dialog opened from the sidebar footer. Rendering is
+ * a no-op while closed; Escape and a backdrop click close it.
+ */
+export declare function QaChangelogModal(props: QaChangelogModalProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=QaChangelog.d.ts.map

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

@@ -1,11 +1,21 @@
+import type { QaImageDraft } from "../../types.js";
 export interface QaComposerProps {
     readonly placeholder: string;
+    readonly quickQuestions?: readonly string[];
     readonly canSend: boolean;
     readonly canStop: boolean;
     readonly running: boolean;
     readonly showStop: boolean;
-    readonly onSend: (text: string) => Promise<boolean>;
+    readonly status: string | null;
+    readonly images: readonly QaImageDraft[];
+    readonly onImagesChange: (images: readonly QaImageDraft[]) => void;
+    readonly onSend: (text: string, images: readonly QaImageDraft[]) => Promise<boolean>;
     readonly onStop: () => Promise<void>;
 }
-export declare function QaComposer(props: QaComposerProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Memoized with the default shallow compare: every prop is a scalar, a
+ * stable array or a stable callback, so a stream of transcript frames never
+ * re-renders the composer and typing stays responsive while an answer runs.
+ */
+export declare const QaComposer: import("react").MemoExoticComponent<(props: QaComposerProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=QaComposer.d.ts.map

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

@@ -1,8 +1,28 @@
-import type { QaMessage as QaMessageModel } from "../../types.js";
+import type { QaMessage as QaMessageModel, QaSource, QaTurnSources } from "../../types.js";
 export interface QaMessageProps {
     readonly message: QaMessageModel;
     readonly renderMarkdown: boolean;
     readonly showTimestamp: boolean;
+    /**
+     * Storage prefix persisted message ratings live under. Callers scope it to
+     * the chat: message ids repeat across chats (`assistant:<seq>`).
+     */
+    readonly stateKey?: string;
+    /** Ask for a fresh variant of this answer; omit to hide the control. */
+    readonly onRegenerate?: () => void;
+    /** Resolve one durable attachment into a viewable URL. */
+    readonly resolveImage?: (attachmentId: string) => Promise<string>;
+    /** Open the drawer at the exact canonical snapshot shown in this footer. */
+    readonly onOpenSources?: (sources: readonly QaSource[], complete: boolean, incompleteOrigins: QaTurnSources["incompleteOrigins"]) => void;
+    /** Open one path-backed source's detail (an inline footnote click). */
+    readonly onSourceDetail?: (source: QaSource) => void;
 }
-export declare function QaMessage({ message, renderMarkdown, showTimestamp, }: QaMessageProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Whether two transcript messages render identically. The transcript
+ * projection rebuilds every message object on each published frame, so the
+ * memoized row compares rendered content instead of references; string
+ * comparison is by value, which keeps fresh copies cheap to recognize.
+ */
+export declare function sameMessage(a: QaMessageModel, b: QaMessageModel): boolean;
+export declare const QaMessage: import("react").MemoExoticComponent<({ message, renderMarkdown, showTimestamp, stateKey, onRegenerate, resolveImage, onOpenSources, onSourceDetail, }: QaMessageProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=QaMessage.d.ts.map

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

@@ -0,0 +1,69 @@
+import type { SessionSummary } from "@deepseek-ai/dsh-api-session-controller/client";
+/** One renderable row of the chat-history sidebar. */
+export interface QaChatRow {
+    readonly id: string;
+    readonly title: string;
+    readonly running: boolean;
+    readonly active: boolean;
+    readonly meta: string;
+    readonly updatedAt: number;
+    /** Chat owner's display name; present in the admin ownership view only. */
+    readonly ownerName?: string;
+}
+/**
+ * Project this browser's indexed chat ids onto the host session list, most
+ * recently updated first. Opening a chat is not an update: only the host's
+ * `updatedAt` (fresh messages) orders the list. Ids the host no longer lists
+ * are skipped (the controller prunes them on switch).
+ */
+export declare function buildChatRows(chatIds: readonly string[], byId: Readonly<Record<string, SessionSummary>>, activeId: string | null, ownerNameOf?: (sessionId: string) => string | undefined, now?: number): readonly QaChatRow[];
+/** One per-owner section of the admin sidebar grouping. */
+export interface QaSidebarSection {
+    /**
+     * Section header; chats nobody claimed group under "Без владельца". An
+     * empty name renders no header (the flat, non-grouped mode).
+     */
+    readonly name: string;
+    readonly rows: readonly QaChatRow[];
+}
+/**
+ * Group rows into per-owner sections for the admin view. Sections order by
+ * their freshest row so the busiest users float up; unclaimed chats go last.
+ * Row order inside a section is already the global updatedAt order.
+ */
+export declare function buildOwnerSections(rows: readonly QaChatRow[]): readonly QaSidebarSection[];
+export interface QaSidebarProps {
+    readonly rows: readonly QaChatRow[];
+    /**
+     * Render per-owner sections instead of the flat list; the admin ownership
+     * view. Rows without an owner name fall into a trailing section.
+     */
+    readonly groupByOwner?: boolean;
+    /** Deployment brand shown next to the logo (also while collapsed). */
+    readonly title: string;
+    /** Optional image logo; a built-in mark is drawn when null. */
+    readonly logoUrl: string | null;
+    /** Storage prefix used to remember the collapsed state across reloads. */
+    readonly stateKey: string;
+    readonly showNewChat: boolean;
+    readonly busy: boolean;
+    readonly onSwitch: (sessionId: string) => void;
+    readonly onNewChat: () => void;
+    /** Removes a chat from this browser's index; omit to hide the control. */
+    readonly onDelete?: (sessionId: string) => void;
+    /** The signed-in account; omit when accounts are disabled. */
+    readonly account?: {
+        readonly email: string;
+        readonly role: string;
+        readonly onLogout: () => void;
+    };
+}
+/**
+ * Whether two sidebar row lists show the same thing. Rows are rebuilt on
+ * every surface render (relative timestamps drift), so the memoized sidebar
+ * compares by content and skips frames that only move the transcript.
+ */
+export declare function sameChatRows(a: readonly QaChatRow[], b: readonly QaChatRow[]): boolean;
+/** The per-browser chat history shown beside the QA conversation. */
+export declare const QaSidebar: import("react").MemoExoticComponent<(props: QaSidebarProps) => import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=QaSidebar.d.ts.map

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

@@ -0,0 +1,20 @@
+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 interface QaSourcesDrawerProps {
+    readonly sources: readonly QaSource[];
+    readonly complete: boolean;
+    readonly incompleteOrigins?: QaTurnSources["incompleteOrigins"];
+    readonly sessionId: string | null;
+    readonly sourceApi: QaBoundSourceApi;
+    readonly display: ResolvedQaSurfaceConfig["sources"]["display"];
+    readonly filePreview: ResolvedQaSurfaceConfig["sources"]["filePreview"];
+    /** Open straight onto this source's detail (an inline footnote click). */
+    readonly initialDetail?: QaSource | null;
+    readonly onClose: () => void;
+}
+/** Canonical grouped source panel and safe local-file preview. */
+export declare function QaSourcesDrawer({ sources, complete, incompleteOrigins, sessionId, sourceApi, display, filePreview, initialDetail, onClose, }: QaSourcesDrawerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaSourcesDrawer.d.ts.map

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

@@ -0,0 +1,59 @@
+import { type RefObject } from "react";
+import type { QaMessage } from "../../types.js";
+/**
+ * One mark of the turn rail: the user prompt that opens the turn, a bounded
+ * answer preview for the hover tooltip, and the message id that anchors the
+ * jump (the prompt's message slot in the transcript).
+ */
+export interface QaTurnRailItem {
+    /** 1-based position in the visible transcript; also the React key. */
+    readonly turn: number;
+    /** The user message id that opens the turn (scroll anchor). */
+    readonly id: string;
+    readonly prompt: string;
+    readonly response: string;
+}
+/** Transcript attribute marking the message slot that opens a turn. */
+export declare const QA_TURN_ANCHOR_ATTRIBUTE = "data-dsh-qa-turn-anchor";
+/** Scroll distance from the floor at which the rail still calls it "at bottom". */
+export declare const QA_TURN_FOLLOW_PX = 96;
+/** The reading line: reading offset from the scrollport top while scrolling. */
+export declare const QA_TURN_READING_PX = 96;
+/**
+ * Rail ladder of the visible transcript: every user prompt opens a turn, the
+ * first non-empty answer after it fills the response preview. Hidden variant
+ * answers never reach this list because callers pass the already-filtered
+ * messages.
+ */
+export declare function buildTurnRailItems(messages: readonly QaMessage[]): readonly QaTurnRailItem[];
+/** Deep equality guard so the memoized rail skips streaming commits. */
+export declare function sameTurnRailItems(left: readonly QaTurnRailItem[], right: readonly QaTurnRailItem[]): boolean;
+/**
+ * Turn owning the transcript's reading line, or the newest one while the
+ * reader follows the live tail. Anchors above the line are scanned in flow
+ * order; the last one at or above it owns the mark.
+ */
+export declare function computeActiveTurn(scroller: HTMLElement, items: readonly QaTurnRailItem[]): number | null;
+export interface QaTurnRailProps {
+    readonly items: readonly QaTurnRailItem[];
+    readonly activeTurn: number | null;
+    /** Turn still generating; its mark pulses. */
+    readonly busyTurn: number | null;
+    /** The transcript scroller the rail floats over and measures its band from. */
+    readonly scrollerRef: RefObject<HTMLDivElement | null>;
+    readonly onNavigate: (item: QaTurnRailItem) => void;
+}
+declare function QaTurnRailView({ items, activeTurn, busyTurn, scrollerRef, onNavigate, }: QaTurnRailProps): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Fixed-pitch rail of every turn of the visible transcript, floating over the
+ * transcript's right gutter: the active mark follows the reading line, a
+ * hover/focus preview shows the prompt and answer, and a click lands the
+ * transcript on that turn. Memoized like the harness rail — the transcript
+ * re-renders on every streaming delta, and the rail only changes when a turn
+ * is added or becomes active.
+ */
+export declare const QaTurnRail: import("react").MemoExoticComponent<typeof QaTurnRailView>;
+/** Land the transcript on a turn's prompt row, harness-style. */
+export declare function turnScrollTarget(scroller: HTMLElement, row: HTMLElement): number;
+export {};
+//# sourceMappingURL=QaTurnRail.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { SettingsOnboardingOwnerProps } from "@deepseek-ai/dsh-client-ui-settings/client";
+import type { StorageLike } from "../types.js";
+/** Bump when the notice changes materially and must be acknowledged again. */
+export declare const QA_WELCOME_NOTICE_VERSION = "2026-09-12.1";
+export declare const QA_WELCOME_NOTICE_COPY: Readonly<{
+    title: "Перед началом тестирования";
+    paragraphs: readonly string[];
+    continueLabel: "Понятно, продолжить";
+}>;
+export interface QaWelcomeNoticeFace {
+    readonly storage: StorageLike;
+    readonly storageKey: string;
+}
+export interface QaWelcomeNoticeProps extends QaWelcomeNoticeFace {
+    readonly complete?: () => void;
+}
+export interface QaWelcomeNoticeStepProps extends SettingsOnboardingOwnerProps, QaWelcomeNoticeFace {
+}
+/** Route-scoped replacement for DSH's stock `welcome-notice` onboarding step. */
+export declare function QaWelcomeNotice(props: QaWelcomeNoticeProps): import("react").ReactPortal | null;
+/**
+ * Invisible shadow for DSH's stock welcome step. The host coordinator removes
+ * onboarding content as soon as a chat stops being blank, so the visible QA
+ * notice is owned by the route overlay above instead of this lifecycle.
+ */
+export declare function QaWelcomeNoticeStep(props: QaWelcomeNoticeStepProps): null;
+//# sourceMappingURL=QaWelcomeNotice.d.ts.map

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

@@ -0,0 +1,36 @@
+import { type RefObject } from "react";
+/** DSH's dragged content-width floor; a lower operator cap still wins. */
+export declare const QA_CONTENT_MIN_WIDTH = 640;
+/**
+ * Space kept outside the content: 88px per side leaves room for the handle,
+ * its inset, and a safe zone that remains draggable in both directions.
+ */
+export declare const QA_CONTENT_EDGE_BUDGET = 176;
+export declare function readQaContentWidth(storage: Pick<Storage, "getItem">, key: string): number | null;
+export declare function writeQaContentWidth(storage: Pick<Storage, "setItem">, key: string, width: number): void;
+/** Resolve the centered content width for the currently available column. */
+export declare function resolveQaContentWidth(columnWidth: number, preference: number | null, maxContentWidth: number): number;
+interface QaWidthHandleProps {
+    readonly side: "left" | "right";
+    readonly onStart: () => number;
+    readonly onDrag: (width: number) => void;
+    readonly onCommit: (width: number) => void;
+    readonly onEnd: () => void;
+}
+/** Pointer-captured, rAF-throttled symmetric content-width handle. */
+export declare function QaWidthHandle(props: QaWidthHandleProps): import("react/jsx-runtime").JSX.Element;
+interface UseQaContentWidthOptions {
+    readonly active: boolean;
+    readonly root: RefObject<HTMLDivElement | null>;
+    readonly storage: Pick<Storage, "getItem" | "setItem">;
+    readonly storageKey: string;
+    readonly maxContentWidth: number;
+}
+export declare function useQaContentWidth({ active, root, storage, storageKey, maxContentWidth, }: UseQaContentWidthOptions): {
+    readonly onStart: () => number;
+    readonly onDrag: (requestedWidth: number) => void;
+    readonly onCommit: (requestedWidth: number) => void;
+    readonly onEnd: () => void;
+};
+export {};
+//# sourceMappingURL=QaWidthHandle.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { QaWorkItem } from "../../types.js";
+export interface QaWorkGroupProps {
+    readonly status: "running" | "complete";
+    readonly startedAt?: number;
+    readonly endedAt?: number;
+    readonly items: readonly QaWorkItem[];
+    readonly renderMarkdown: boolean;
+}
+export declare const THINKING_PHRASES: readonly string[];
+/**
+ * Whether two work items render identically. The transcript projection
+ * rebuilds every item object on each published frame, so memoized work rows
+ * compare by rendered content instead of by reference.
+ */
+export declare function sameWorkItem(a: QaWorkItem, b: QaWorkItem): boolean;
+/** Whether two work item lists render identically, item for item. */
+export declare function sameWorkItems(a: readonly QaWorkItem[], b: readonly QaWorkItem[]): boolean;
+export declare const QaWorkGroup: import("react").MemoExoticComponent<({ status, startedAt, endedAt, items, renderMarkdown, }: QaWorkGroupProps) => import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=QaWorkGroup.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { QaMessage } from "../../types.js";
+export interface QaVariantGroup {
+    /** The user message that anchors the group. */
+    readonly groupId: string;
+    /** Answer turns triggered by that message, in order. */
+    readonly turns: readonly number[];
+}
+/**
+ * Group answer turns under the user message that triggered them. The session
+ * has no truncation seam, so a regenerated answer is a real follow-up turn;
+ * consecutive turns after one user message read as its variants.
+ */
+export declare function collectVariantGroups(messages: readonly QaMessage[]): readonly QaVariantGroup[];
+export declare function VariantSwitcher({ count, offset, onStep, }: {
+    readonly count: number;
+    readonly offset: number;
+    readonly onStep: (offset: number) => void;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=VariantSwitcher.d.ts.map

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

@@ -0,0 +1,9 @@
+/** Shared time formatting for the QA surface UI. */
+/** `только что`, `5 мин`, `3 ч`, `2 дн` or a ru-RU date past the week. */
+export declare function relativeTime(timestamp: number, now: number): string;
+/** `9 сент 15:44` - compact ru-RU day/month plus time. */
+export declare function formatDayTime(timestamp: number): string;
+/** `1,1 с` below ten seconds, `8 с` above. */
+export declare function formatSeconds(ms: number): string;
+export declare function formatWorkDuration(durationMs: number): string;
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { QaSource } from "../../types.js";
+/**
+ * Match layer between assistant text and the canonical turn sources: markdown
+ * links resolve by normalized URL, inline-code tokens by file path. A token
+ * that matches nothing keeps its plain rendering — the surface never guesses.
+ */
+export interface QaSourceRefs {
+    /** Identity of the source set; memo comparators compare this. */
+    readonly signature: string;
+    resolveUrl(url: string): QaSource | undefined;
+    resolvePath(token: string): QaSource | undefined;
+}
+/** Display name for a file-backed source: the file name alone, case kept. */
+export declare function sourceFileName(source: QaSource): string;
+export declare function buildSourceRefs(sources: readonly QaSource[]): QaSourceRefs;
+//# sourceMappingURL=source-refs.d.ts.map

package/lib/types/client/create-session.d.ts

@@ -0,0 +1,16 @@
+import type { ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaSessions, QaSessionsApi } from "./types.js";
+/**
+ * Create one Host session and pin the configured preset and model onto the
+ * still-blank session. The creation wire takes no preset, so
+ * agentPresets/select recomposes the agent and durably logs
+ * `agent-preset/selected`, which the client projection replays. The session
+ * is addressed only here — no prompt can run before the caller attests the
+ * composed preset.
+ */
+export declare function createQaSession(args: {
+    readonly sessions: QaSessions;
+    readonly api: QaSessionsApi;
+    readonly config: ResolvedQaSurfaceConfig;
+}): Promise<string>;
+//# sourceMappingURL=create-session.d.ts.map

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

@@ -1,18 +1,15 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { ConnectionHandle } from "@deepseek-ai/dsh-client-connection/client";
-import type { ISessions } from "@deepseek-ai/dsh-client-runtime/client";
-import type { SettingsScopeBinder } from "@deepseek-ai/dsh-client-ui-settings/client";
 declare module "@deepseek-ai/cordis" {
     interface Context {
         connection: ConnectionHandle;
-        sessions: ISessions;
-        settingsScope: SettingsScopeBinder;
     }
 }
 export declare const inject: string[];
 /** Register the route-aware, full-frame QA entry in the additive overlay slot. */
-export declare function apply(ctx: Context): void;
+export declare function apply(ctx: Context): Promise<() => Promise<void>>;
 export { QaConfigController } from "./QaConfigController.js";
+export { QaAccountsController } from "./QaAccountsController.js";
 export { QaRouteController, matchesQaRoute } from "./QaRouteController.js";
 export { QaSessionController } from "./QaSessionController.js";
 export { projectTranscript } from "./QaTranscriptAdapter.js";

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

@@ -0,0 +1,30 @@
+import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
+import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { QaSessionState, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
+/** Everything the bound-chat projection reads; the computation is pure. */
+export interface QaBoundProjectionInput {
+    readonly connected: boolean;
+    readonly sessionId: string;
+    readonly sessionSnapshot: ReturnType<SessionFace["getSnapshot"]>;
+    readonly conversationSnapshot: ConversationSnapshot | undefined;
+    /** Turn bundles with the Host provenance already merged in (Host wins). */
+    readonly sourceBundles: readonly QaTurnSources[];
+    readonly operationError: string | null;
+    readonly policyReady: boolean;
+    readonly admissionPending: boolean;
+    readonly chatsRevision: number;
+    readonly viewingSubagent: QaSubagentView | null;
+    readonly config: ResolvedQaSurfaceConfig;
+    /**
+     * The chat owner's display name for author labels; present only when an
+     * admin reads a foreign chat (chat-level, not per-message).
+     */
+    readonly author?: string;
+}
+/**
+ * Project one bound chat into the observable surface state: phase, transcript
+ * with per-turn sources, footer sources, and the composer's capabilities.
+ * Side effects (host-bundle refresh, notifications) live in the controller.
+ */
+export declare function projectBoundSessionState(input: QaBoundProjectionInput): QaSessionState;
+//# sourceMappingURL=project-session-state.d.ts.map

package/lib/types/client/session-admission.d.ts

@@ -0,0 +1,23 @@
+import type { QaSecureSession } from "./types.js";
+import type { ResolvedQaSurfaceConfig } from "../types.js";
+export type QaAttestationOutcome = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    /** The identity is absent or expired; the caller returns to the gate. */
+    readonly authRequired: boolean;
+    readonly reason: string | null;
+};
+/**
+ * One send-time policy attestation against the Host admission gate. The
+ * QA-facing message stays generic by design; the coarse reason plus an
+ * operator hint go to the console once per refusal.
+ */
+export declare function attestQaPolicy(args: {
+    readonly secureSession: QaSecureSession;
+    readonly token: string;
+    readonly sessionId: string;
+    readonly lockdown: ResolvedQaSurfaceConfig["lockdown"];
+    readonly report: boolean;
+}): Promise<QaAttestationOutcome>;
+//# sourceMappingURL=session-admission.d.ts.map

package/lib/types/client/session-assets.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-chat cache of resolved attachment URLs. Attachment reads are
+ * session-scoped (the loader reads the bound session's durable store), and
+ * attachment ids are only unique within a chat, so both the cache and the
+ * blob lifetime are keyed by chat, not by the page.
+ */
+export declare class SessionAssetRepository {
+    private readonly bySession;
+    /** Resolve one attachment of one chat, deduplicating concurrent reads. */
+    resolve(sessionId: string, attachmentId: string, load: (attachmentId: string) => Promise<string>): Promise<string>;
+    /**
+     * Revoke the chat's blob URLs and drop its cache. Data URLs need no
+     * revocation; a failed resolution never produced a URL at all.
+     */
+    release(sessionId: string): void;
+    dispose(): void;
+}
+/** Revoke one blob URL; data URLs (and other runtimes) need nothing. */
+export declare function revokeObjectUrlIfBlob(url: string): void;
+//# sourceMappingURL=session-assets.d.ts.map

package/lib/types/client/session-sources.d.ts

@@ -0,0 +1,28 @@
+import type { QaTurnSources } from "../types.js";
+import type { QaSourceApi } from "./types.js";
+/**
+ * Host-side provenance of the bound chat. The client projects turn sources
+ * from durable conversation events; the Host bundle (which also carries
+ * subagent-inherited evidence) is fetched on the side and merged by turn,
+ * Host data winning over the projection.
+ */
+export declare class QaHostSourceBridge {
+    private readonly sourceApi;
+    private readonly token;
+    private bundles;
+    private signature;
+    private refreshing;
+    /** Bumped on reset so a stale in-flight fetch never lands. */
+    private generation;
+    constructor(sourceApi: QaSourceApi, token: () => string);
+    /** Leave the chat: drop its bundles; merging degrades to the projection. */
+    reset(): void;
+    merge(projected: readonly QaTurnSources[]): readonly QaTurnSources[];
+    /**
+     * Fetch the Host bundles of one chat; a changed payload republishes through
+     * the callback. Repeated calls coalesce while one is in flight, and a
+     * response that outlives the chat is dropped.
+     */
+    refresh(sessionId: string, onChanged: () => void): Promise<void>;
+}
+//# sourceMappingURL=session-sources.d.ts.map

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

@@ -0,0 +1,6 @@
+/** Fold the host settlement wording into a title plus the closing message. */
+export declare function parseSettlement(text: string): {
+    title: string;
+    body: string;
+} | undefined;
+//# sourceMappingURL=settlement.d.ts.map

package/lib/types/client/tool-presentation.d.ts

@@ -0,0 +1,6 @@
+import type { ToolResultNode } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { QaWorkItem } from "../types.js";
+export declare function flattenToolOutput(node: ToolResultNode): string | null;
+export declare function toolStatus(node: ToolResultNode): "ok" | "error" | "stopped";
+export declare function workTool(callId: string, name: string, argsRaw: string, status: "running" | "ok" | "error" | "stopped", startedAt: number | undefined, endedAt: number | undefined, output: string | null): QaWorkItem;
+//# sourceMappingURL=tool-presentation.d.ts.map

package/lib/types/client/turn-sources.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { LegacyConversationSlice } from "@deepseek-ai/dsh-client-ui-chat/client";
+import type { QaSource, QaTurnSources } from "../types.js";
+/** The transcript-bearing Chat slice of one Conversation snapshot (absent before the view activates). */
+export declare function chatLegacyOf(snapshot: ConversationSnapshot | undefined): LegacyConversationSlice;
+/**
+ * Rebuild canonical turn bundles from durable tool-result metadata. Since the
+ * metadata is persisted by DSH, this projection is identical on live updates
+ * and replay and requires no assistant-authored bibliography.
+ */
+export declare function projectTurnSources(snapshot: ConversationSnapshot | undefined, sessionId?: string, workspaceRoot?: string): readonly QaTurnSources[];
+/** Visible evidence sources for the latest turn, shared by the drawer/footer. */
+export declare function projectSources(snapshot: ConversationSnapshot | undefined, sessionId?: string, workspaceRoot?: string): readonly QaSource[];
+//# sourceMappingURL=turn-sources.d.ts.map