@yadsh/dsh-qa-surface 0.2.0 → 0.4.0

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

@@ -0,0 +1,43 @@
+import { type RefObject } from "react";
+/**
+ * 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. It is
+ * the whole ceiling too: like DSH, the page bounds the width, so a wide column
+ * lets the transcript fill it.
+ */
+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. The
+ * operator sets only the floor; the column is the ceiling, so the content may
+ * grow until its handles reach the edge budget and a wider window keeps
+ * widening it. A column too narrow even for the floor wins over the floor —
+ * there is nothing else to give up.
+ */
+export declare function resolveQaContentWidth(columnWidth: number, preference: number | null, minContentWidth: 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 minContentWidth: number;
+}
+export declare function useQaContentWidth({ active, root, storage, storageKey, minContentWidth, }: UseQaContentWidthOptions): {
+    readonly onStart: () => number;
+    readonly onDrag: (requestedWidth: number) => void;
+    readonly onCommit: (requestedWidth: number) => void;
+    readonly onEnd: () => void;
+};
+export type UseQaContentWidthResult = ReturnType<typeof useQaContentWidth>;
+export {};
+//# sourceMappingURL=QaWidthHandle.d.ts.map

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

@@ -1,12 +1,14 @@
 import type { QaWorkItem } from "../../types.js";
 export interface QaWorkGroupProps {
-    readonly status: "running" | "complete";
+    /** "error" marks a turn the host ended with a provider failure. */
+    readonly status: "running" | "complete" | "error";
     readonly startedAt?: number;
     readonly endedAt?: number;
     readonly items: readonly QaWorkItem[];
     readonly renderMarkdown: boolean;
+    /** Operator-configured running phrases; omitted reads the built-in list. */
+    readonly thinkingPhrases?: readonly string[];
 }
-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
@@ -15,5 +17,5 @@ export declare const THINKING_PHRASES: readonly string[];
 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>;
+export declare const QaWorkGroup: import("react").MemoExoticComponent<({ status, startedAt, endedAt, items, renderMarkdown, thinkingPhrases, }: QaWorkGroupProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=QaWorkGroup.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/components/surface-utils.d.ts

@@ -0,0 +1,11 @@
+import type { QaSessionState } from "../../types.js";
+/**
+ * Small pure projections of the session state shared by surface regions: the
+ * composer's status line and the conversation title. Keeping them out of
+ * QaSurface leaves that file pure composition.
+ */
+/** The composer's status line, or null when nothing is due. */
+export declare function statusText(state: QaSessionState, runningPhrase: string | null): string | null;
+/** The conversation title derived from the first user prompt, clipped. */
+export declare function titleFromMessages(state: QaSessionState): string | null;
+//# sourceMappingURL=surface-utils.d.ts.map

package/lib/types/client/components/thinking-phrases.d.ts

@@ -0,0 +1,9 @@
+import { DEFAULT_THINKING_PHRASES, thinkingPhrase } from "../../thinking-phrases.js";
+export { DEFAULT_THINKING_PHRASES, thinkingPhrase };
+/**
+ * Phrase for a turn that started at `startedAt`. Every reader that passes the
+ * same start time and phrase list lands on the same phrase, so the composer
+ * hint and the work list never disagree.
+ */
+export declare function useThinkingPhrase(running: boolean, startedAt: number | undefined, phrases?: readonly string[]): string | null;
+//# sourceMappingURL=thinking-phrases.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { QaCreateSession } from "./types.js";
+/**
+ * Ask the QA Host boundary to create a fully composed session. The browser
+ * supplies only its account token and cannot select cwd, workspace, owner,
+ * preset, model, or permission policy. The resulting session
+ * is addressed only here — no prompt can run before the caller attests the
+ * composed preset.
+ */
+export declare function createQaSession(args: {
+    readonly createSession: QaCreateSession;
+    readonly token: string;
+}): Promise<string>;
+//# sourceMappingURL=create-session.d.ts.map

package/lib/types/client/failure-copy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * QA-facing copy for provider failures, keyed by the stable failure code the
+ * host records on retry and turn-end events. Raw provider messages never
+ * reach these rows — they can carry stack traces and local paths — so every
+ * text here derives from the code alone.
+ */
+/** Terminal turn-failure row shown after the work group. */
+export declare function turnErrorCopy(code: string | undefined): string;
+export interface RetryCopySource {
+    readonly mode: "normal" | "always";
+    readonly retry: number;
+    readonly maxRetries?: number;
+    readonly delayMs: number;
+    readonly retryState: "scheduled" | "started" | "cancelled";
+    readonly failureCode?: string;
+}
+/** Work-group row for one host-scheduled model-request retry. */
+export declare function retryWorkCopy(node: RetryCopySource): string;
+//# sourceMappingURL=failure-copy.d.ts.map

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

@@ -9,6 +9,7 @@ export declare const inject: string[];
 /** Register the route-aware, full-frame QA entry in the additive overlay slot. */
 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/prompt-content.d.ts

@@ -0,0 +1,30 @@
+import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
+import type { QaAttachmentDraft, QaFileDraft } from "../types.js";
+import type { QaFileUpload, QaPromptContent } from "./types.js";
+/**
+ * Stage every pending file on the Host and collect the receipts the prompt
+ * cites. Sequential on purpose: a partial batch must be attributable to the
+ * exact file that failed, and the visitor's file counts are small.
+ * `service` is undefined on a page the deployment serves without the upload
+ * plugin, which leaves attachments unavailable rather than broken. The
+ * receipt is opaque and host-minted — the upload service answers with a
+ * plain string, and only the session wire brand knows it as an id.
+ */
+export declare function stageQaFiles(service: QaFileUpload | undefined, session: SessionFace, files: readonly QaFileDraft[]): Promise<{
+    readonly kind: "ok";
+    readonly receipts: Map<string, string>;
+} | {
+    readonly kind: "unavailable";
+} | {
+    readonly kind: "failed";
+}>;
+/**
+ * Assemble the wire content of one prompt: the text part, images riding the
+ * prompt inline, and files cited by their staged receipts. The visitor's own
+ * order decides the prompt order, so images and files are assembled from one
+ * walk over the drafts; an unpaired file receipt (a draft kept while its
+ * staging failed elsewhere) degrades to an empty receipt rather than
+ * dropping the attachment.
+ */
+export declare function buildQaPromptContent(prompt: string, attachments: readonly QaAttachmentDraft[], receipts: ReadonlyMap<string, string>): QaPromptContent;
+//# sourceMappingURL=prompt-content.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/settings/card.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The QA Surface settings card.
+ *
+ * Two sources meet here: the `qa-surface` settings namespace, which is the
+ * page's configuration source on the Host, and the `qaSurface/describe`
+ * Remote, which reports the configuration the running Host actually resolved.
+ * Everything the user changes is written immediately as a path-addressed
+ * mutation; the status view re-reads the Remote while the card is visible, so
+ * a saved change is confirmed against the Host rather than against the form.
+ */
+import type { SettingsScope } from "@deepseek-ai/dsh-client-ui-settings/client";
+import type { InjectFace, PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
+import type { RemoteResult } from "@deepseek-ai/dsh-typert-protocol";
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../../types.js";
+/** The face the slot entry injects into this card. */
+export interface QaSettingsCardFace {
+    readonly scope: SettingsScope<QaSurfaceConfig>;
+    describe(): Promise<RemoteResult<ResolvedQaSurfaceConfig>>;
+}
+type CardProps = PropsRuntime<"settings.plugin.item"> & InjectFace<QaSettingsCardFace>;
+export declare function QaSettingsCard({ scope, describe }: CardProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=card.d.ts.map

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

@@ -0,0 +1,139 @@
+/**
+ * Shared controls of the QA Surface card body.
+ *
+ * Every control edits the settings namespace through the same path-addressed
+ * write, and text and number drafts commit on blur or Enter rather than per
+ * keystroke: a half-typed path or an emptied number is a value the Host
+ * refuses, and a refusal mid-typing would clear the field the user is still
+ * editing. Controls that must land together (a provider with its model, the
+ * per-user sandbox with its flag) write every path in one mutation, because
+ * the Host validates the section as a whole.
+ */
+import { type ReactNode } from "react";
+import { type IdentityFieldDraft } from "./format.js";
+/** One field write inside the plugin's settings namespace. */
+export interface ConfigEntry {
+    readonly path: readonly string[];
+    readonly value: unknown;
+}
+/** Path-addressed write into the plugin's settings namespace. */
+export type ConfigWrite = (path: readonly string[], value: unknown) => void;
+/** Several path-addressed writes applied as one mutation. */
+export type ConfigWriteMany = (entries: readonly ConfigEntry[]) => void;
+/** Path-addressed clear, so the field re-inherits the composition layer. */
+export type ConfigUnset = (path: readonly string[]) => void;
+/** Whether the raw user layer carries a path. */
+export type OverrideCheck = (path: readonly string[]) => boolean;
+export interface SectionProps {
+    readonly writable: boolean;
+    readonly write: ConfigWrite;
+    readonly writeMany: ConfigWriteMany;
+    readonly unset: ConfigUnset;
+    readonly overridden: OverrideCheck;
+}
+/** Section frame: title, optional modified marker, optional trailing control. */
+export declare function Section(props: {
+    title: string;
+    modified: boolean;
+    hint?: ReactNode;
+    aside?: ReactNode;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** Small clearing control shown beside a section the user layer overrides. */
+export declare function ResetButton(props: {
+    disabled: boolean;
+    label: string;
+    onClick: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+/** Two-state control with a label and an explanatory hint. */
+export declare function Toggle(props: {
+    checked: boolean;
+    disabled: boolean;
+    label: string;
+    hint: string;
+    onChange: (checked: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;
+/** Fixed-option control for the schema's string unions. */
+export declare function SelectField(props: {
+    label: string;
+    value: string;
+    disabled: boolean;
+    options: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
+    hint?: string;
+    onChange: (value: string) => void;
+}): import("react/jsx-runtime").JSX.Element;
+/** Text control; the draft commits on blur and on Enter. */
+export declare function TextField(props: {
+    label: string;
+    value: string;
+    disabled: boolean;
+    placeholder?: string;
+    hint?: string;
+    multiline?: boolean;
+    rows?: number;
+    onChange: (value: string) => void;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Whole-number control; the draft commits on blur and on Enter. A value
+ * outside the range snaps into it on commit, so the field never holds a
+ * number the Host would refuse outright.
+ */
+export declare function NumberField(props: {
+    label: string;
+    value: number;
+    min: number;
+    max: number;
+    disabled: boolean;
+    hint?: string;
+    onChange: (value: number) => void;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * List control for string arrays. The draft parses on commit so a separator
+ * the user is still typing never becomes a stored entry.
+ */
+export declare function ListField(props: {
+    label: string;
+    hint?: string;
+    value: readonly string[];
+    disabled: boolean;
+    placeholder?: string;
+    rows?: number;
+    parse: (text: string) => string[];
+    onCommit: (values: string[]) => void;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * The deployment's declared profile fields, one `key = подпись` per line. The
+ * control keeps its own draft so a line still being typed is not parsed into
+ * the stored array.
+ */
+export declare function IdentitiesField(props: {
+    value: ReadonlyArray<{
+        readonly key?: string | undefined;
+        readonly label?: string | undefined;
+    }>;
+    disabled: boolean;
+    onCommit: (fields: IdentityFieldDraft[]) => void;
+}): import("react/jsx-runtime").JSX.Element;
+/** Status chip pair: label and value with the mode's tone. */
+export declare function Chip(props: {
+    label: string;
+    value: string;
+    tone?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** Prose notice: informational or warning, never a control. */
+export declare function Notice(props: {
+    tone: "info" | "warn";
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** Fixed facts of the composed policy, shown as label/value rows. */
+export declare function Facts(props: {
+    items: ReadonlyArray<{
+        label: string;
+        value: string;
+        note?: string;
+    }>;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=fields.d.ts.map

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

@@ -0,0 +1,108 @@
+/**
+ * Pure presentation helpers of the QA Surface settings card.
+ *
+ * Kept out of the components so the wording and the draft parsing are
+ * unit-testable without a DOM, and so every place that renders the same value
+ * renders it identically. Nothing here may reach the Host config surface: the
+ * card bundle must not pull schemastery into the page.
+ */
+import type { QaSurfaceConfig } from "../../types.js";
+/** A control's label with the sentence explaining what it does. */
+export interface DescribedOption {
+    readonly label: string;
+    readonly hint: string;
+}
+/**
+ * Header badge: the route the page answers on, or that the surface is off.
+ * The route is the one fact an operator scanning the plugin list looks for.
+ */
+export declare function badgeText(enabled: boolean | undefined, routePath: string | undefined): string;
+/** Wording of the session-policy control. */
+export declare function describeSessionPolicy(policy: string | undefined): DescribedOption;
+/** Wording of the sandbox-mode control. */
+export declare function describeSandbox(mode: string | undefined): DescribedOption;
+/**
+ * Parse a numeric control's draft text.
+ * @param text - raw input value.
+ * @param min - lowest accepted value, clamped into range on commit.
+ * @param max - highest accepted value, clamped into range on commit.
+ * @returns the integer, or null when the field is empty or not numeric (the
+ * caller leaves the stored value alone rather than writing a NaN).
+ */
+export declare function parseNumberDraft(text: string, min: number, max: number): number | null;
+/**
+ * Parse a one-entry-per-line list control's draft text. Questions and phrases
+ * are free copy, so a comma inside an entry must stay part of that entry.
+ */
+export declare function parseLineList(text: string): string[];
+/** Parse a list control whose entries may also be comma-separated. */
+export declare function parseCommaList(text: string): string[];
+/** One declared identity field as the operator writes it. */
+export interface IdentityFieldDraft {
+    readonly key: string;
+    readonly label: string;
+}
+/**
+ * Parse the identity-field control: one `key = подпись` entry per line. A
+ * missing label falls back to the key, and an entry whose key cannot exist on
+ * the Host is dropped here rather than refused as a whole write.
+ */
+export declare function parseIdentityFields(text: string): IdentityFieldDraft[];
+/** Render declared identity fields back into the control's draft text. */
+export declare function formatIdentityFields(fields: readonly IdentityFieldDraft[] | undefined): string;
+/**
+ * Prerequisites `accounts.perUserWorkspace` cannot run without. The Host
+ * refuses the configuration while any of them is unmet, and the sandbox mode
+ * is the one entry the card must write together with the flag: both
+ * `workspace-write` alone and per-user workspaces alone are refused.
+ */
+export declare function perUserWorkspaceGaps(config: QaSurfaceConfig): string[];
+/**
+ * Whether the raw user layer carries this path, which is what marks a field
+ * overridden — a value equal to the composition default is still an override.
+ * @param user - raw user section from the settings snapshot.
+ * @param path - path from the section root.
+ * @returns true when every segment exists in the user layer.
+ */
+export declare function isOverridden(user: unknown, path: readonly string[]): boolean;
+/** Top-level keys the user layer carries; the reset-all action clears exactly these. */
+export declare function overriddenKeys(user: unknown): string[];
+/**
+ * Read a path out of a settings section.
+ * @param value - section root (the snapshot's effective value or user layer).
+ * @param path - path from the section root.
+ * @returns the value found, or undefined when any segment is absent.
+ */
+export declare function readPath(value: unknown, path: readonly string[]): unknown;
+/**
+ * Whether a settled mutation left the section holding what it asked for.
+ *
+ * The scope resolves a Host-rejected write instead of rejecting it — it
+ * reloads Host state and returns — so acceptance is confirmed here. The
+ * namespace revision advances on every committed change, and a write that
+ * changed nothing is indistinguishable from a refusal; in that one case the
+ * section itself answers whether the value already stood.
+ * @param entries - writes the mutation asked for.
+ * @param cleared - paths the mutation asked to clear.
+ * @param snapshot - the scope snapshot as it stands after the settlement.
+ * @returns true when the mutation's intent is visible in the section.
+ */
+export declare function mutationLanded(entries: readonly {
+    readonly path: readonly string[];
+    readonly value: unknown;
+}[], cleared: readonly (readonly string[])[], snapshot: {
+    readonly value: unknown;
+    readonly user: unknown;
+}): boolean;
+/** Wall-clock stamp of the last Host answer, for the status line. */
+export declare function formatClock(timestamp: number | undefined): string;
+/**
+ * Count with the Russian form of its noun: 1 ключ, 2 ключа, 5 ключей.
+ * @param count - counted value.
+ * @param forms - singular, few, and many forms of the noun.
+ * @returns the counted noun as the copy renders it.
+ */
+export declare function pluralRu(count: number, forms: readonly [string, string, string]): string;
+/** Thousands separator so long byte budgets stay readable. */
+export declare function formatCount(value: number | undefined): string;
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Access and route: the only section whose consequences reach beyond this
+ * plugin's namespace — the path it claims on the Host and where external
+ * visitors of the harness root land.
+ */
+import { type ConfigProps } from "./common.js";
+/** Where the page lives and who may reach it. */
+export declare function AccessSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=access.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Accounts: the account gate, the self-declared profile, and per-user
+ * workspaces. The per-user toggle lands together with the sandbox mode —
+ * the Host accepts that pairing or nothing.
+ */
+import { type ConfigProps } from "./common.js";
+/** The account gate, the self-declared profile, and per-user workspaces. */
+export declare function AccountsSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=accounts.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * Attachments: what a visitor may attach to one message. Like the interface
+ * section, the list fields show the value in effect — a stored list, else the
+ * Host's resolved one — so an untouched deployment never sees an empty box
+ * for a setting that is active.
+ */
+import { type ConfigProps } from "./common.js";
+/**
+ * What a visitor may attach to one message. Files never ride the prompt
+ * inline: the browser stages them on the Host and the prompt cites the
+ * receipt, so the model resolves the stored copy through its file tools — the
+ * deployment's tool allow-list has to keep `read` for that to be useful.
+ */
+export declare function AttachmentsSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=attachments.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Branding: pure copy the visitor reads, so nothing here constrains what the
+ * Host accepts — every field is free-form and safe to leave empty.
+ */
+import { type ConfigProps } from "./common.js";
+/** Titles, welcome copy, and the notice under the composer. */
+export declare function BrandingSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=branding.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * What the config sections share: the props every section receives, the
+ * override check behind the modified marker, and the reset control that
+ * clears a whole section with one click.
+ */
+import type { ReactNode } from "react";
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../../../types.js";
+import { type SectionProps } from "../fields.js";
+export interface ConfigProps extends SectionProps {
+    readonly config: QaSurfaceConfig | undefined;
+    /**
+     * What the running Host resolved, when it answered. A control whose default
+     * is not a literal — the running phrases — reads the effective list from
+     * here instead of showing an empty field for a setting that is in effect.
+     */
+    readonly effective: ResolvedQaSurfaceConfig | null;
+}
+/** The setting paths one section owns; its reset clears them in order. */
+export type SectionPaths = ReadonlyArray<readonly string[]>;
+/** Whether the user layer overrides any of the paths the section owns. */
+export declare function overriddenAny(props: ConfigProps, paths: SectionPaths): boolean;
+/**
+ * The reset control beside a section whose paths the user layer overrides:
+ * one button clearing every path of the section, disabled while the settings
+ * namespace itself is read-only.
+ */
+export declare function resetAside(props: ConfigProps, paths: SectionPaths): ReactNode;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Embedding: one CSP field with a wide blast radius — an overly generous
+ * frame-ancestors list lets any listed site run this page as its own UI.
+ */
+import { type ConfigProps } from "./common.js";
+/** Embedding the page into another site's frame. */
+export declare function EmbeddingSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=embedding.d.ts.map