@yadsh/dsh-qa-surface 0.2.0 → 0.4.0

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

@@ -0,0 +1,9 @@
+/**
+ * Interface: what the visitor sees of the conversation. The show-reset toggle
+ * stays disabled while the lockdown section withholds session reset — the
+ * Host refuses one without the other.
+ */
+import { type ConfigProps } from "./common.js";
+/** What the visitor sees of the conversation. */
+export declare function InterfaceSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=interface.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Lockdown: the execution policy every QA chat is pinned to. Its fixed
+ * choices are not editable on purpose — the Host rejects any configuration
+ * that relaxes them, so the card explains rather than offers.
+ */
+import { type ConfigProps } from "./common.js";
+/** The execution policy every QA chat is pinned to. */
+export declare function LockdownSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=lockdown.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Session: which chat a visitor gets, and which agent and model serve it.
+ * Provider and model are written as one mutation because the Host refuses
+ * either of them alone.
+ */
+import { type ConfigProps } from "./common.js";
+/** Which chat a visitor gets, and which agent and model serve it. */
+export declare function SessionSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Sources: which sources the assistant may cite and how they are shown. Most
+ * of the controls live behind "advanced" disclosures so the default view
+ * carries only the collection switches a deployment actually argues about.
+ */
+import { type ConfigProps } from "./common.js";
+/** Which sources the assistant may cite, and how they are shown. */
+export declare function SourcesSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=sources.d.ts.map

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

@@ -0,0 +1,22 @@
+/**
+ * The status view: what the deployment actually serves, read from the running
+ * Host rather than from the settings snapshot.
+ */
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../../../types.js";
+export interface StatusProps {
+    /** Effective configuration the running Host answered with, when it did. */
+    readonly effective: ResolvedQaSurfaceConfig | null;
+    /** Settings snapshot shown while the Host has not answered. */
+    readonly config: QaSurfaceConfig | undefined;
+    readonly refreshing: boolean;
+    readonly refreshedAt: number | undefined;
+    readonly overrides: number;
+    readonly onRefresh: () => void;
+}
+/**
+ * What the deployment is actually serving: the route, the session policy, the
+ * execution policy, and the account gate, as the Host resolved them. The card
+ * polls this while it is open, so a saved change is confirmed here.
+ */
+export declare function StatusSection(props: StatusProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1,25 @@
+/**
+ * Body sections of the QA Surface settings card.
+ *
+ * Each section owns its controls and derives every value from the settings
+ * snapshot (the effective configuration) or, for the status view, from the
+ * running Host through the `qaSurface/describe` Remote. The controls mirror
+ * the Host's own validation: combinations the resolver refuses are either
+ * written together in one mutation or explained rather than offered.
+ *
+ * One file per section lives in `sections/`, with what the config sections
+ * share in `sections/common.tsx`; this module is the barrel the card imports.
+ */
+export type { ConfigProps } from "./sections/common.js";
+export { AccessSection } from "./sections/access.js";
+export { AccountsSection } from "./sections/accounts.js";
+export { AttachmentsSection } from "./sections/attachments.js";
+export { BrandingSection } from "./sections/branding.js";
+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 { SourcesSection } from "./sections/sources.js";
+export { StatusSection } from "./sections/status.js";
+export type { StatusProps } from "./sections/status.js";
+//# sourceMappingURL=sections.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Card stylesheet: the canonical shell (AGENTS.md contract) plus body rules
+ * for this plugin's own controls. Every surface, border, and colour comes from
+ * `--dsw-alias-*` tokens so light, dark, and system themes stay coherent; the
+ * QA page's own palette stays out of the settings page.
+ */
+export declare const QA_SETTINGS_STYLES: string;
+//# sourceMappingURL=styles.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/stream-publisher.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Spacing for a running turn's stream frames. A running turn's frames arrive
+ * at animation-frame cadence, so re-projections are spaced at least the
+ * configured interval apart: the first frame of a window projects at once and
+ * further frames are absorbed (the memoized render path replays nothing, so
+ * absorbing a frame only defers it). Everything outside a running turn —
+ * phase flips, errors, turn completion — projects immediately, and a
+ * non-running notification also cancels an absorbed window so the final
+ * state never waits for it. Zero disables the spacing entirely.
+ */
+export declare class StreamPublisher {
+    private readonly intervalMs;
+    private timer;
+    constructor(intervalMs: number);
+    /**
+     * Deliver one notification. `running` says whether the bound session is
+     * mid-turn; `emit` performs the actual projection and must stay cheap to
+     * defer.
+     */
+    publish(running: boolean, emit: () => void): void;
+    /**
+     * Cancel an absorbed window so the next frame projects at once. Called
+     * when the binding goes away or the controller winds down: a stale window
+     * must not swallow the first frame of a fresh binding.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=stream-publisher.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

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

@@ -1,23 +1,114 @@
-import type { IApiClient } from "@deepseek-ai/dsh-client-connection/client";
-import type { ISessions, SessionRuntime } from "@deepseek-ai/dsh-client-runtime/client";
-import type { QaLockdownProof, QaSessionState } from "../types.js";
-import type { SessionFace } from "@deepseek-ai/dsh-client-runtime/client";
+import type { ClientRemote } from "@deepseek-ai/dsh-api-gateway/client";
+import type { ISessions, SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
+import type { UiConversation } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { QaAccountProfileInput, QaAccountSession, QaAccountUserPublic, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaSessionState, QaSourceFilePreview, QaTurnSources, QaWhoamiResult } from "../types.js";
 /** Wire content one prompt carries: text plus base64 image uploads. */
 export type QaPromptContent = Parameters<SessionFace["prompt"]>[0];
 /** DSH session runtime surface the QA controller is allowed to touch. */
-export type QaSessions = ISessions & Pick<SessionRuntime, "create">;
+export type QaSessions = ISessions;
 /** Narrow client API slice used to pin the preset and model of a fresh chat. */
-export type QaSessionsApi = Pick<IApiClient["sessions"], "selectModel"> & {
-    readonly selectAgentPreset: IApiClient["agentPresets"]["select"];
+export type QaSessionsApi = {
+    selectModel: ClientRemote["session"]["selectModel"];
+    selectAgentPreset: ClientRemote["agentPresets"]["select"];
 };
-/** Attestation channel to the Host admission boundary (`qaSurface/secureSession`). */
-export type QaSecureSession = (sessionId: string) => Promise<{
+/**
+ * Conversation assembly the QA transcript is projected from: the per-Session
+ * binding carries the assembled Chat view (nodes, partials, tool calls).
+ */
+export type QaConversation = Pick<UiConversation, "binding">;
+/**
+ * Attestation channel to the Host admission boundary
+ * (`qaSurface/secureSession`). The account token rides as the first argument
+ * when accounts are enabled; an empty string is the anonymous caller.
+ */
+export type QaSecureSession = (token: string, sessionId: string) => Promise<{
     readonly ok: true;
     readonly value: QaLockdownProof;
 } | {
     readonly ok: false;
     readonly error: unknown;
 }>;
+/** Host-authoritative creation: identity, cwd and policy never come from the browser. */
+export type QaCreateSession = (token: string) => Promise<RemoteResult<string>>;
+/**
+ * Browser file-upload service (`ctx.fileUpload`), described structurally on
+ * purpose: files do not ride the prompt inline the way images do, they are
+ * staged through the Host upload route and cited by receipt. The QA bundle
+ * must not link the upload package — a deployment may not serve it — so the
+ * service is read off the context at send time and this is the only shape the
+ * surface relies on.
+ */
+export interface QaFileUpload {
+    upload(sessionId: string, data: Blob | Uint8Array, name?: string, signal?: AbortSignal): Promise<{
+        readonly ok: true;
+        readonly value: {
+            readonly receiptId: string;
+            readonly file: {
+                readonly attachmentId: string;
+                readonly name: string;
+                readonly bytes: number;
+            };
+        };
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+}
+export interface QaSourceApi {
+    sources(token: string, sessionId: string): Promise<{
+        readonly ok: true;
+        readonly value: readonly QaTurnSources[];
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+    readSourceFile(token: string, sessionId: string, sourcePath: string): Promise<{
+        readonly ok: true;
+        readonly value: QaSourceFilePreview;
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+}
+/** A source API with the account token already bound at the call site. */
+export type QaBoundSourceApi = {
+    sources(sessionId: string): Promise<{
+        readonly ok: true;
+        readonly value: readonly QaTurnSources[];
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+    readSourceFile(sessionId: string, sourcePath: string): Promise<{
+        readonly ok: true;
+        readonly value: QaSourceFilePreview;
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+};
+/** Account remotes exposed by the plugin's own typert namespace. */
+export interface QaAccountsApi {
+    accountsWhoami(token: string): Promise<RemoteResult<QaWhoamiResult>>;
+    accountsLogin(email: string, password: string): Promise<RemoteResult<QaAccountSession>>;
+    accountsRegister(email: string, password: string): Promise<RemoteResult<QaAccountSession>>;
+    accountsClaimSessions(token: string, sessionIds: readonly string[]): Promise<RemoteResult<QaClaimResult>>;
+    accountsOwnedSessions(token: string): Promise<RemoteResult<{
+        readonly ids: readonly string[];
+    }>>;
+    accountsListOwnership(token: string): Promise<RemoteResult<{
+        readonly entries: readonly QaOwnershipEntry[];
+    }>>;
+    /** Replace the caller's own self-declared profile; the token is the identity. */
+    accountsUpdateProfile(token: string, input: QaAccountProfileInput): Promise<RemoteResult<QaAccountUserPublic>>;
+}
+type RemoteResult<Value> = {
+    readonly ok: true;
+    readonly value: Value;
+} | {
+    readonly ok: false;
+    readonly error: unknown;
+};
 /** Minimal persistence contract; backed by `window.localStorage` in the app. */
 export interface StorageLike {
     getItem(key: string): string | null;
@@ -26,4 +117,5 @@ export interface StorageLike {
 }
 /** The state projected while no QA chat is bound (route inactive or booting). */
 export declare const QA_SESSION_IDLE_STATE: QaSessionState;
+export {};
 //# sourceMappingURL=types.d.ts.map

package/lib/types/client/use-right-rail.d.ts

@@ -0,0 +1,56 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { QaSource, QaTurnSources } from "../types.js";
+import type { QaDrawerCompleteness, QaRailTab } from "./use-session-ui-state.js";
+/**
+ * The rail-related slice of `useSessionUiState`, declared structurally so the
+ * controller consumes exactly what it drives and the rest of the chat-local
+ * state (draft text, variant offsets, the turn mark) stays with the surface.
+ */
+export interface QaRightRailState {
+    readonly railOpen: boolean;
+    readonly setRailOpen: Dispatch<SetStateAction<boolean>>;
+    readonly railTab: QaRailTab;
+    readonly setRailTab: Dispatch<SetStateAction<QaRailTab>>;
+    readonly drawerSources: readonly QaSource[] | null;
+    readonly setDrawerSources: Dispatch<SetStateAction<readonly QaSource[] | null>>;
+    readonly drawerCompleteness: QaDrawerCompleteness | null;
+    readonly setDrawerCompleteness: Dispatch<SetStateAction<QaDrawerCompleteness | null>>;
+    readonly drawerDetail: QaSource | null;
+    readonly setDrawerDetail: Dispatch<SetStateAction<QaSource | null>>;
+    readonly setAgentsOpen: Dispatch<SetStateAction<boolean>>;
+}
+/** What QaSurface reads and hands to the rail, the panels and the header. */
+export interface QaRightRailFacade {
+    readonly railOpen: boolean;
+    readonly railTab: QaRailTab;
+    /** Message-scoped source pin, or null for the whole-chat list. */
+    readonly drawerSources: readonly QaSource[] | null;
+    readonly drawerCompleteness: QaDrawerCompleteness | null;
+    readonly drawerDetail: QaSource | null;
+    /** A message footer's sources control: pin the message-scoped subset. */
+    readonly openSources: (sources: readonly QaSource[], complete: boolean, incompleteOrigins: QaTurnSources["incompleteOrigins"]) => void;
+    /** A message's source chip: show that source's detail instead of a list. */
+    readonly openSourceDetail: (source: QaSource) => void;
+    /** Back to the whole-chat source list, dropping the pin. */
+    readonly showAllSources: () => void;
+    /** Closing the rail also discards the pinned sources, as the drawer did. */
+    readonly close: () => void;
+    /**
+     * The header buttons: a second click on the active tab's button closes the
+     * rail; opening the sources tab shows the full list, dropping any pin.
+     */
+    readonly openTab: (tab: QaRailTab) => void;
+    /** The rail strip's plain tab switch. */
+    readonly selectTab: (tab: QaRailTab) => void;
+    /** The agents drawer and the rail are mutually exclusive; this is its side. */
+    readonly toggleAgents: () => void;
+}
+/**
+ * Right-rail controller over the chat-local drawer state: every transition
+ * between the whole-chat list, a pinned message subset and a single source's
+ * detail lives here, so the surface only wires controls to intents. The
+ * callbacks stay referentially stable — they close over `useState` setters,
+ * whose identities never change.
+ */
+export declare function useRightRail(ui: QaRightRailState): QaRightRailFacade;
+//# sourceMappingURL=use-right-rail.d.ts.map

package/lib/types/client/use-session-ui-state.d.ts

@@ -0,0 +1,41 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { QaAttachmentDraft, QaSource, QaTurnSources } from "../types.js";
+/** Snapshot completeness captured when a drawer was opened from a message. */
+export interface QaDrawerCompleteness {
+    readonly complete: boolean;
+    readonly incompleteOrigins?: QaTurnSources["incompleteOrigins"];
+}
+/** The rail tab ids; the agents drawer has not become a tab yet. */
+export type QaRailTab = "sources" | "files";
+export interface QaSessionUiState {
+    /** Per group: how many answers back from the newest is shown (0 = newest). */
+    readonly variantOffsets: Record<string, number>;
+    readonly setVariantOffsets: Dispatch<SetStateAction<Record<string, number>>>;
+    /** The turn the transcript's reading line currently owns. */
+    readonly activeTurn: number | null;
+    readonly setActiveTurn: Dispatch<SetStateAction<number | null>>;
+    readonly agentsOpen: boolean;
+    readonly setAgentsOpen: Dispatch<SetStateAction<boolean>>;
+    /** Whether the right rail column is shown. */
+    readonly railOpen: boolean;
+    readonly setRailOpen: Dispatch<SetStateAction<boolean>>;
+    /** Which rail tab is active; meaningful only while the rail is open. */
+    readonly railTab: QaRailTab;
+    readonly setRailTab: Dispatch<SetStateAction<QaRailTab>>;
+    readonly drawerSources: readonly QaSource[] | null;
+    readonly setDrawerSources: Dispatch<SetStateAction<readonly QaSource[] | null>>;
+    readonly drawerCompleteness: QaDrawerCompleteness | null;
+    readonly setDrawerCompleteness: Dispatch<SetStateAction<QaDrawerCompleteness | null>>;
+    readonly drawerDetail: QaSource | null;
+    readonly setDrawerDetail: Dispatch<SetStateAction<QaSource | null>>;
+    readonly pendingAttachments: readonly QaAttachmentDraft[];
+    readonly setPendingAttachments: (next: readonly QaAttachmentDraft[]) => void;
+}
+/**
+ * Per-chat UI state: composer attachments, variant offsets, the rail mark and
+ * the drawers. Everything here describes the chat it was made in, so a
+ * session change clears it instead of leaking a draft, an attachment or a
+ * drawer from one conversation into the next.
+ */
+export declare function useSessionUiState(sessionId: string | null): QaSessionUiState;
+//# sourceMappingURL=use-session-ui-state.d.ts.map

package/lib/types/client/use-transcript-view.d.ts

@@ -0,0 +1,20 @@
+import type { QaMessage } from "../types.js";
+import { type QaTurnRailItem } from "./components/QaTurnRail.js";
+import { type QaVariantGroup } from "./components/VariantSwitcher.js";
+export interface QaTranscriptView {
+    readonly visibleMessages: readonly QaMessage[];
+    /** Answer groups by the user message id that opens them. */
+    readonly groupByPromptId: ReadonlyMap<string, QaVariantGroup>;
+    /** Per group: the turn the current variant offset selects. */
+    readonly selectedTurn: ReadonlyMap<string, number>;
+    readonly railItems: readonly QaTurnRailItem[];
+}
+/**
+ * Memoized transcript view model. The controller republishes state with a
+ * fresh messages array on every stream frame, but re-renders that keep the
+ * transcript unchanged (drawers, the active turn mark, variant offsets) must
+ * not re-run the projections — and per-row group lookups go through a map
+ * instead of a linear find inside the render loop.
+ */
+export declare function useTranscriptView(messages: readonly QaMessage[], variantOffsets: Record<string, number>): QaTranscriptView;
+//# sourceMappingURL=use-transcript-view.d.ts.map

package/lib/types/config-resolvers/accounts.d.ts

@@ -0,0 +1,15 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type AccountsSlice = ResolvedQaSurfaceConfig["accounts"];
+/** Resolved neighbors the per-user workspace boundary is checked against. */
+export interface AccountsDependencies {
+    readonly session: ResolvedQaSurfaceConfig["session"];
+    readonly lockdown: ResolvedQaSurfaceConfig["lockdown"];
+}
+/**
+ * Resolve the accounts domain. The per-user workspace boundary spans session
+ * and lockdown, so their resolved slices arrive as dependencies and the
+ * boundary checks run here, next to the flag they guard.
+ */
+export declare function resolveAccounts(input: QaSurfaceConfig, dependencies: AccountsDependencies): AccountsSlice;
+export {};
+//# sourceMappingURL=accounts.d.ts.map

package/lib/types/config-resolvers/attachments.d.ts

@@ -0,0 +1,6 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type AttachmentsSlice = ResolvedQaSurfaceConfig["attachments"];
+/** Resolve the attachments domain: intake toggles and byte/line bounds. */
+export declare function resolveAttachments(input: QaSurfaceConfig): AttachmentsSlice;
+export {};
+//# sourceMappingURL=attachments.d.ts.map

package/lib/types/config-resolvers/basics.d.ts

@@ -0,0 +1,8 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+export declare function normalizeRoutePath(value: string): string;
+/** The scalar domains that carry no table-shaped or cross-domain rules. */
+type BasicsSlice = Pick<ResolvedQaSurfaceConfig, "enabled" | "route" | "branding" | "embedding" | "entry" | "interaction">;
+/** Resolve the master switch, route, branding, embedding, and entry domains. */
+export declare function resolveBasics(input: QaSurfaceConfig): BasicsSlice;
+export {};
+//# sourceMappingURL=basics.d.ts.map

package/lib/types/config-resolvers/defaults.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedQaSurfaceConfig } from "../types.js";
+/** The canonical resolved config; every domain resolver defaults from it. */
+export declare const DEFAULT_QA_SURFACE_CONFIG: ResolvedQaSurfaceConfig;
+//# sourceMappingURL=defaults.d.ts.map

package/lib/types/config-resolvers/lockdown.d.ts

@@ -0,0 +1,10 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type LockdownSlice = ResolvedQaSurfaceConfig["lockdown"];
+/**
+ * Resolve the lockdown domain. The capability flags are clamped shut, and
+ * showing the reset control needs an explicit authorization here, so the
+ * resolved UI slice arrives as a neighbor.
+ */
+export declare function resolveLockdown(input: QaSurfaceConfig, ui: ResolvedQaSurfaceConfig["ui"]): LockdownSlice;
+export {};
+//# sourceMappingURL=lockdown.d.ts.map

package/lib/types/config-resolvers/session.d.ts

@@ -0,0 +1,6 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type SessionSlice = ResolvedQaSurfaceConfig["session"];
+/** Resolve the session domain: policy, pinning, and model selection. */
+export declare function resolveSession(input: QaSurfaceConfig): SessionSlice;
+export {};
+//# sourceMappingURL=session.d.ts.map

package/lib/types/config-resolvers/shared.d.ts

@@ -0,0 +1,16 @@
+/** Trim an optional string; a blank value collapses to null. */
+export declare function optionalText(value: string | null | undefined): string | null;
+/**
+ * Shared numeric guard for operator-tuned limits: the value has to be a safe
+ * integer inside [min, max], and every rejection carries the same message.
+ */
+export declare function assertIntInRange(name: string, value: number, min: number, max: number): void;
+/** Deduplicate and trim the operator's quick questions. */
+export declare function uniqueQuestions(values: readonly string[]): readonly string[];
+/**
+ * Normalize the operator's phrase list. Unlike quick questions, an empty list
+ * cannot mean "hide the control": the running indicator has to say something,
+ * so emptiness restores the built-in phrases.
+ */
+export declare function uniquePhrases(values: readonly string[]): readonly string[];
+//# sourceMappingURL=shared.d.ts.map

package/lib/types/config-resolvers/sources.d.ts

@@ -0,0 +1,6 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type SourcesSlice = ResolvedQaSurfaceConfig["sources"];
+/** Resolve the sources domain: collection, display, and preview bounds. */
+export declare function resolveSources(input: QaSurfaceConfig): SourcesSlice;
+export {};
+//# sourceMappingURL=sources.d.ts.map

package/lib/types/config-resolvers/ui.d.ts

@@ -0,0 +1,6 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type UiSlice = ResolvedQaSurfaceConfig["ui"];
+/** Resolve the UI domain: widget visibility and the content width floor. */
+export declare function resolveUi(input: QaSurfaceConfig): UiSlice;
+export {};
+//# sourceMappingURL=ui.d.ts.map

package/lib/types/entry-redirect.d.ts

@@ -0,0 +1,20 @@
+import type { ResolvedQaSurfaceConfig } from "./types.js";
+/**
+ * The operator/LAN split is decided client-side on `location.hostname` on
+ * purpose: behind the qa-deploy proxy every request appears loopback to the
+ * Host, and the deployment convention is "operator uses localhost, QA users
+ * use the LAN address". `?ui=admin` persists the operator escape hatch under
+ * the deployment's storage key; `?ui=qa` clears it again.
+ */
+export declare function entryRedirectScript(config: ResolvedQaSurfaceConfig): string;
+export interface EntryRedirectRow {
+    readonly kind: "script";
+    readonly placement: "head";
+    readonly text: string;
+}
+/**
+ * The structured index-injection row for one config snapshot, or undefined
+ * when the plugin is disabled or the redirect flag is off.
+ */
+export declare function entryRedirectRow(config: ResolvedQaSurfaceConfig): EntryRedirectRow | undefined;
+//# sourceMappingURL=entry-redirect.d.ts.map

package/lib/types/host-route.d.ts

@@ -1,9 +1,22 @@
+import type { IncomingMessage } from "node:http";
 import type { WebServer } from "@deepseek-ai/dsh-host-webserver";
 import type { ResolvedQaSurfaceConfig } from "./types.js";
+import type { LaunchTokenSource } from "./launch-token.js";
+export interface QaNavigationRouteOptions {
+    /**
+     * Resolves the process launch token; when supplied and the browser carries
+     * no host-auth cookie, the route defers the marker hand-off in favor of the
+     * one-time `/?token=` exchange (relative location: the browser mints the
+     * cookie on the origin it actually used).
+     */
+    readonly launchToken?: LaunchTokenSource;
+}
+/** Presence-only check: an invalid cookie still fails the root gate later. */
+export declare function hasHostAuthCookie(request: IncomingMessage): boolean;
 /**
  * DSH 0.1.1 static hosting returns 404 for missing paths. Redirect a browser
  * navigation through its canonical index entry; the client restores the
  * requested pathname before activating the QA overlay.
  */
-export declare function registerQaNavigationRoute(webServer: Pick<WebServer, "register">, config: ResolvedQaSurfaceConfig): () => void;
+export declare function registerQaNavigationRoute(webServer: Pick<WebServer, "register">, config: ResolvedQaSurfaceConfig, options?: QaNavigationRouteOptions): () => void;
 //# sourceMappingURL=host-route.d.ts.map