@runtypelabs/persona 4.17.0 → 4.18.0

package/dist/history-view.d.ts

@@ -0,0 +1,1461 @@
+interface TooltipOptions {
+    /** The control the tooltip describes and positions against. */
+    anchor: HTMLElement;
+    /** Hover target. Defaults to `anchor`; wrappers make small icon buttons easier to hit. */
+    trigger?: HTMLElement;
+    /** Tooltip copy. A callback keeps live aria-label updates in sync. */
+    text: string | (() => string);
+    /**
+     * Muted chip after the label, e.g. a keyboard shortcut. Empty renders
+     * nothing. A callback is re-read on every reposition, like `text`.
+     */
+    hint?: string | (() => string);
+    /** Whether the visual tooltip may open. The anchor's accessible name is unaffected. */
+    enabled?: boolean;
+    /** Gap between the control and tooltip, in pixels. */
+    gap?: number;
+    /** Minimum distance from viewport edges, in pixels. */
+    viewportPadding?: number;
+    /**
+     * Hover wait before the first tooltip. Falls back to the widget
+     * `tooltip.delayMs` (default 200). Keyboard focus ignores this.
+     */
+    delayMs?: number;
+    /**
+     * After a tooltip closes, later hovers in this window skip `delayMs`.
+     * Falls back to the widget `tooltip.skipDelayMs` (default 300).
+     */
+    skipDelayMs?: number;
+}
+interface TooltipHandle {
+    readonly isOpen: boolean;
+    show(): void;
+    hide(): void;
+    reposition(): void;
+    destroy(): void;
+}
+
+type RuntypeExecutionStreamEvent = ({
+    agentId?: string;
+    agentName?: string;
+    config?: Record<string, unknown>;
+    executionId: string;
+    flowId?: string;
+    flowName?: string;
+    kind: "agent" | "flow";
+    maxTurns?: number;
+    seq: number;
+    source?: string;
+    startedAt: string;
+    totalSteps?: number;
+    type: "execution_start";
+}) | ({
+    claudeManagedAgentId?: string;
+    completedAt?: string;
+    durationMs?: number;
+    executionId: string;
+    externalAgent?: {
+        contextId?: string;
+        taskId?: string;
+    };
+    failedSteps?: number;
+    finalOutput?: string;
+    iterations?: number;
+    kind: "agent" | "flow";
+    seq: number;
+    stepErrorCount?: number;
+    stopReason?: string;
+    success: boolean;
+    successfulSteps?: number;
+    totalCost?: number;
+    totalSteps?: number;
+    totalTokens?: {
+        input: number;
+        output: number;
+    };
+    totalTokensUsed?: number;
+    type: "execution_complete";
+}) | ({
+    blockReason?: string;
+    code?: string;
+    completedAt?: string;
+    error: string | {
+        code: string;
+        details?: Record<string, unknown>;
+        message: string;
+    };
+    executionId: string;
+    kind: "agent" | "flow";
+    seq: number;
+    type: "execution_error";
+    upgradeUrl?: string;
+}) | ({
+    executionId: string;
+    id: string;
+    iteration?: number;
+    role: "user" | "assistant" | "system";
+    seq: number;
+    turnIndex?: number;
+    type: "turn_start";
+}) | ({
+    completedAt?: string;
+    content?: string;
+    cost?: number;
+    estimatedContextBreakdown?: {
+        categories: Record<string, {
+            chars: number;
+            estimatedTokens: number;
+        }>;
+        contextWindowSize?: number;
+        estimatedTotalTokens: number;
+        estimatedUtilizationPercent?: number;
+    };
+    executionId: string;
+    fallback?: {
+        attempts: Array<{
+            attempt: number;
+            error?: string;
+            model?: string;
+            success: boolean;
+            type: "retry" | "model" | "message" | "flow";
+        }>;
+        exhausted: boolean;
+        model?: string;
+        reason?: string | null;
+        used: boolean;
+    };
+    id: string;
+    iteration?: number;
+    role: "user" | "assistant" | "system";
+    seq: number;
+    stopReason?: "end_turn" | "max_tool_calls" | "length" | "content_filter" | "error" | "unknown";
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    type: "turn_complete";
+}) | {
+    executionId: string;
+    id: string;
+    index?: number;
+    name?: string;
+    outputVariable?: string;
+    seq: number;
+    startedAt?: string;
+    stepType?: string;
+    totalSteps?: number;
+    type: "step_start";
+} | ({
+    completedAt?: string;
+    cost?: number;
+    durationMs?: number;
+    error?: string;
+    executionId: string;
+    fallback?: {
+        attempts: Array<{
+            attempt: number;
+            error?: string;
+            model?: string;
+            success: boolean;
+            type: "retry" | "model" | "message" | "flow";
+        }>;
+        exhausted: boolean;
+        model?: string;
+        reason?: string | null;
+        used: boolean;
+    };
+    id: string;
+    name?: string;
+    result?: unknown;
+    seq: number;
+    stepType?: string;
+    stopReason?: "end_turn" | "max_tool_calls" | "length" | "content_filter" | "error" | "unknown";
+    success?: boolean;
+    tokensUsed?: number;
+    type: "step_complete";
+    unresolvedVariables?: Array<string>;
+}) | {
+    executionId: string;
+    id: string;
+    index?: number;
+    name?: string;
+    seq: number;
+    skippedAt?: string;
+    stepType?: string;
+    totalSteps?: number;
+    type: "step_skip";
+    when?: string;
+} | ({
+    executionId: string;
+    id: string;
+    parentToolCallId?: string;
+    role?: "user" | "assistant" | "system";
+    seq: number;
+    stepId?: string;
+    turnId?: string;
+    type: "text_start";
+}) | {
+    delta: string;
+    executionId: string;
+    id: string;
+    seq: number;
+    type: "text_delta";
+} | {
+    executionId: string;
+    id: string;
+    seq: number;
+    text?: string;
+    type: "text_complete";
+} | ({
+    executionId: string;
+    id: string;
+    parentToolCallId?: string;
+    scope?: "turn" | "loop";
+    seq: number;
+    type: "reasoning_start";
+}) | {
+    delta: string;
+    executionId: string;
+    id: string;
+    seq: number;
+    type: "reasoning_delta";
+} | ({
+    executionId: string;
+    id: string;
+    scope?: "turn" | "loop";
+    seq: number;
+    text?: string;
+    type: "reasoning_complete";
+}) | ({
+    executionId: string;
+    id: string;
+    mediaType: string;
+    role?: "user" | "assistant" | "system";
+    seq: number;
+    toolCallId?: string;
+    type: "media_start";
+}) | {
+    delta: string;
+    executionId: string;
+    id: string;
+    seq: number;
+    type: "media_delta";
+} | {
+    data?: string;
+    executionId: string;
+    id: string;
+    mediaType?: string;
+    seq: number;
+    toolCallId?: string;
+    type: "media_complete";
+    url?: string;
+} | ({
+    artifactType: "markdown" | "component";
+    component?: string;
+    executionId?: string;
+    file?: {
+        language?: string;
+        mimeType: string;
+        path: string;
+    };
+    id: string;
+    seq?: number;
+    title?: string;
+    type: "artifact_start";
+}) | {
+    delta: string;
+    executionId?: string;
+    id: string;
+    seq?: number;
+    type: "artifact_delta";
+} | {
+    component: string;
+    executionId?: string;
+    id: string;
+    props: Record<string, unknown>;
+    seq?: number;
+    type: "artifact_update";
+} | {
+    executionId?: string;
+    id: string;
+    seq?: number;
+    type: "artifact_complete";
+} | {
+    executionId: string;
+    id?: string;
+    seq: number;
+    sourceType?: string;
+    title?: string;
+    type: "source";
+    url?: string;
+    [key: string]: unknown;
+} | {
+    executionId: string;
+    iteration?: number;
+    seq: number;
+    state: Record<string, unknown>;
+    type: "state_snapshot";
+} | ({
+    executionId: string;
+    iteration?: number;
+    patch: Array<{
+        from?: string;
+        op: "add" | "remove" | "replace" | "move" | "copy" | "test";
+        path: string;
+        value?: unknown;
+    }>;
+    seq: number;
+    type: "state_delta";
+}) | ({
+    executionId: string;
+    hiddenParameterNames?: Array<string>;
+    iteration?: number;
+    origin?: "webmcp" | "sdk";
+    pageOrigin?: string;
+    parameters?: Record<string, unknown>;
+    seq: number;
+    startedAt?: string;
+    stepId?: string;
+    toolCallId: string;
+    toolName: string;
+    toolType: string;
+    type: "tool_start";
+}) | {
+    delta: string;
+    executionId: string;
+    seq: number;
+    toolCallId: string;
+    type: "tool_input_delta";
+} | {
+    executionId: string;
+    hiddenParameterNames?: Array<string>;
+    parameters: Record<string, unknown>;
+    seq: number;
+    toolCallId: string;
+    toolName?: string;
+    type: "tool_input_complete";
+} | {
+    delta: string;
+    executionId: string;
+    seq: number;
+    toolCallId: string;
+    type: "tool_output_delta";
+} | {
+    error?: string;
+    executionId: string;
+    executionTime?: number;
+    iteration?: number;
+    result?: unknown;
+    seq: number;
+    stepId?: string;
+    success: boolean;
+    toolCallId: string;
+    toolCost?: number;
+    toolName?: string;
+    type: "tool_complete";
+} | {
+    approvalId: string;
+    description?: string;
+    executionId: string;
+    externalAgent?: {
+        contextId?: string;
+        taskId?: string;
+    };
+    iteration?: number;
+    parameters?: Record<string, unknown>;
+    reason?: string;
+    seq: number;
+    startedAt?: string;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
+    timeout?: number;
+    toolCallId?: string;
+    toolName: string;
+    toolType?: string;
+    type: "approval_start";
+} | ({
+    approvalId: string;
+    completedAt?: string;
+    decision: "approved" | "denied" | "timeout";
+    executionId: string;
+    resolvedBy?: "user" | "system";
+    seq: number;
+    type: "approval_complete";
+}) | ({
+    awaitReason?: string;
+    awaitedAt?: string;
+    crawlId?: string;
+    elicitation?: {
+        message: string;
+        mode: "form" | "url";
+        pauseCount?: number;
+        requestedSchema?: Record<string, unknown>;
+        requests?: Array<{
+            message: string;
+            mode: "form" | "url";
+            name: string;
+            requestedSchema?: Record<string, unknown>;
+            url?: string;
+        }>;
+        serverName?: string;
+        url?: string;
+    };
+    executionId: string;
+    externalAgent?: {
+        contextId?: string;
+        taskId?: string;
+    };
+    origin?: "webmcp" | "sdk";
+    pageOrigin?: string;
+    parameters?: Record<string, unknown>;
+    seq: number;
+    stepId?: string;
+    toolCallId?: string;
+    toolId?: string;
+    toolName?: string;
+    type: "await";
+}) | ({
+    error: string | {
+        code: string;
+        details?: Record<string, unknown>;
+        message: string;
+    };
+    executionId: string;
+    recoverable?: boolean;
+    seq: number;
+    type: "error";
+}) | {
+    executionId: string;
+    seq: number;
+    timestamp: string;
+    type: "ping";
+} | {
+    executionId?: string;
+    name: string;
+    seq?: number;
+    type: "custom";
+    value?: unknown;
+};
+type RuntypeStreamEventOf<U, T extends string> = Extract<U, {
+    type: T;
+}>;
+type RuntypeTurnCompleteEvent = RuntypeStreamEventOf<RuntypeExecutionStreamEvent, "turn_complete">;
+type RuntypeStepCompleteEvent = RuntypeStreamEventOf<RuntypeExecutionStreamEvent, "step_complete">;
+type RuntypeStopReasonKind = NonNullable<RuntypeTurnCompleteEvent["stopReason"] | RuntypeStepCompleteEvent["stopReason"]>;
+
+/**
+ * History provider seam (`docs/visitor-history-implementation-plan.md` D9).
+ * Session/UI history code depends on this interface, never on
+ * `AgentWidgetClient`.
+ *
+ * The module stays under `internal/` but its contract is public: `index-core.ts`
+ * re-exports these declarations so integrators can implement
+ * `features.history.provider`. The provider REGISTRY beside it stays private.
+ */
+
+/** Fixed for the lifetime of one opened history view/action chain. */
+interface HistoryOperationContext {
+    scope: HistoryScope;
+}
+/**
+ * An authorized-but-not-yet-applied conversation activation. The provider must
+ * not mutate the active chat until `commit()`.
+ */
+interface PreparedHistoryActivation {
+    conversationId: string;
+    conversationRevision: string;
+    /** Apply the already-authorized provider-specific transport/session binding. */
+    commit(): void | Promise<void>;
+    /** Idempotently abandon a stale/superseded activation without changing chat. */
+    discard(): void;
+}
+interface HistoryListOptions {
+    cursor?: string;
+    limit?: number;
+    targetId?: string;
+    context: HistoryOperationContext;
+}
+interface HistoryListResult {
+    items: HistoryConversationSummary[];
+    nextCursor: string | null;
+}
+interface HistoryPageOptions {
+    cursor?: string;
+    /** Lets the provider synthesize stable timestamps across page boundaries. */
+    beforeCreatedAt?: string;
+    context: HistoryOperationContext;
+}
+interface HistoryPageResult {
+    summary: HistoryConversationSummary;
+    /** Already mapped; the visitor-visible projection lives in `content`. */
+    messages: AgentWidgetMessage[];
+    conversationRevision: string;
+    /** Follow for the next older page. `null` at the start of the transcript. */
+    nextCursor: string | null;
+}
+interface HistoryDeleteAllOptions {
+    /** Absent means the whole authorized scope, never the UI default. */
+    targetId?: string;
+    context: HistoryOperationContext;
+}
+/** The contract a `features.history.provider` implementation satisfies. */
+interface HistoryProvider {
+    readonly capabilities: {
+        scopes: readonly HistoryScope[];
+    };
+    getIdentityStatus(): HistoryIdentityStatus;
+    subscribeIdentityStatus(callback: (status: HistoryIdentityStatus) => void): () => void;
+    list(opts: HistoryListOptions): Promise<HistoryListResult>;
+    getPage(id: string, opts: HistoryPageOptions): Promise<HistoryPageResult>;
+    prepareOpen(id: string, opts: {
+        context: HistoryOperationContext;
+    }): Promise<PreparedHistoryActivation>;
+    prepareStartNew(opts: {
+        context: HistoryOperationContext;
+    }): Promise<PreparedHistoryActivation>;
+    delete(id: string, opts: {
+        context: HistoryOperationContext;
+    }): Promise<void>;
+    deleteAll(opts: HistoryDeleteAllOptions): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Optional capability: visitor-scoped rename/star. Absence hides every
+     * update affordance (star glyphs, built-in title-menu actions). A user-set
+     * title pins: the provider must never let a later auto-generated title
+     * overwrite one set through this call.
+     */
+    update?(id: string, patch: HistoryConversationPatch, opts: {
+        context: HistoryOperationContext;
+    }): Promise<HistoryConversationSummary>;
+    /**
+     * Optional capability. Absence hides "forget this device". Resolves (never
+     * rejects) on remote failure; credentials are cleared in `finally` either way.
+     */
+    resetDevice?(): Promise<{
+        remoteRevocationConfirmed: boolean;
+    }>;
+    subscribeAvailability?(callback: (available: boolean) => void): () => void;
+}
+
+/**
+ * Text content part for multi-modal messages
+ */
+type TextContentPart = {
+    type: 'text';
+    text: string;
+};
+/**
+ * Image content part for multi-modal messages
+ * Supports base64 data URIs or URLs
+ */
+type ImageContentPart = {
+    type: 'image';
+    image: string;
+    mimeType?: string;
+    alt?: string;
+};
+/**
+ * File content part for multi-modal messages
+ * Supports PDF, TXT, DOCX, and other document types
+ */
+type FileContentPart = {
+    type: 'file';
+    data: string;
+    mimeType: string;
+    filename: string;
+};
+/**
+ * Audio content part for multi-modal messages
+ * Supports base64 data URIs or URLs
+ */
+type AudioContentPart = {
+    type: 'audio';
+    audio: string;
+    mimeType?: string;
+};
+/**
+ * Video content part for multi-modal messages
+ * Supports base64 data URIs or URLs
+ */
+type VideoContentPart = {
+    type: 'video';
+    video: string;
+    mimeType?: string;
+};
+/**
+ * Union type for all content part types
+ */
+type ContentPart = TextContentPart | ImageContentPart | FileContentPart | AudioContentPart | VideoContentPart;
+/** Reference stored on a sent message for transcript fidelity + chip rendering. */
+type AgentWidgetContextMentionRef = {
+    sourceId: string;
+    itemId: string;
+    label: string;
+    iconName?: string;
+    /** Accent color for the inline token (see `AgentWidgetContextMentionItem.color`). */
+    color?: string;
+};
+/**
+ * One ordered segment of a sent message's prose, for inline mention rendering
+ * (`contextMentions.display: "inline"`). Text runs and atomic mention tokens
+ * interleave in document order so the sent bubble re-renders `@tokens` in place
+ * and composer history can round-trip them. Display/transcript concern only —
+ * the model still sees resolved bodies via `llmContent`/`contentParts`.
+ */
+type AgentWidgetContentSegment = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "mention";
+    ref: AgentWidgetContextMentionRef;
+};
+/**
+ * Metadata attached to messages created during agent execution.
+ */
+type AgentMessageMetadata = {
+    executionId?: string;
+    iteration?: number;
+    turnId?: string;
+    agentName?: string;
+    /**
+     * When this message was produced by a step inside a nested flow executed
+     * as a tool, identifies the parent tool call id. Enables renderers to
+     * visually group or indent nested-flow output under its parent tool.
+     */
+    parentToolId?: string;
+    /**
+     * Nested flow step id that produced this message (e.g. a `send-stream`
+     * or `prompt` step inside the nested flow). Stable key for that step.
+     */
+    parentStepId?: string;
+    /**
+     * Set to `true` on a tool-variant message produced from a `step_await`
+     * event (`awaitReason: "local_tool_required"`). Signals to UI code that
+     * the tool call is a LOCAL tool and the server is paused waiting for a
+     * `POST /v1/dispatch/resume` with the user's answer keyed by tool name.
+     */
+    awaitingLocalTool?: boolean;
+    /**
+     * The provider per-call id (`toolu_…`) carried on the `step_await` /
+     * `flow_await` events for a LOCAL tool (core#3878). Present only when the
+     * server emits it. Two PARALLEL calls to the same tool in one turn share a
+     * `toolName` (and a collapsed `toolId`) but get DISTINCT `webMcpToolCallId`s,
+     * so this is the key the widget batches a single `/resume` on: preferred
+     * over tool name, which collides for same-tool parallel calls. Absent →
+     * fall back to the legacy name-keyed resume contract.
+     */
+    webMcpToolCallId?: string;
+    /**
+     * Set to `true` once the user has picked / typed / dismissed an answer for
+     * an `ask_user_question` tool call, so renderers stop re-mounting the
+     * answer-pill sheet for this tool call on subsequent render passes.
+     */
+    askUserQuestionAnswered?: boolean;
+    /**
+     * In-progress answers for a multi-question `ask_user_question` payload,
+     * keyed by question text. Persisted across refresh so the user lands back
+     * where they were if the page reloads mid-flow. Cleared once
+     * `askUserQuestionAnswered` flips to `true`.
+     */
+    askUserQuestionAnswers?: Record<string, string | string[]>;
+    /**
+     * Current page index for a multi-question `ask_user_question` payload's
+     * paginated stepper. Persists alongside `askUserQuestionAnswers`.
+     */
+    askUserQuestionIndex?: number;
+    /**
+     * Set to `true` once a `suggest_replies` tool call's fire-and-forget
+     * `/resume` has been accepted by the server. Persisted belt-and-suspenders
+     * mirror of the in-memory resolved-key dedupe, so hydration/re-emit paths
+     * never re-resume the call.
+     */
+    suggestRepliesResolved?: boolean;
+};
+/**
+ * Copy overrides for the visitor-facing conversation history surface. These are
+ * the widget's only localization mechanism for history, so every user-visible
+ * history string is listed here.
+ */
+interface AgentWidgetHistoryCopy {
+    /** Title of the history view. Defaults to "Messages". */
+    viewTitle?: string;
+    /** Heading shown when the visitor has no stored conversations. */
+    emptyTitle?: string;
+    /** Body text shown when the visitor has no stored conversations. */
+    emptyDescription?: string;
+    /** Heading shown when a history request fails. */
+    errorTitle?: string;
+    /** Body text shown when a history request fails. */
+    errorDescription?: string;
+    /** Label for the retry action on the error state. */
+    retryLabel?: string;
+    /** Heading shown after a 429 rate-limited history response. */
+    rateLimitedTitle?: string;
+    /** Body text shown after a 429 rate-limited history response. */
+    rateLimitedDescription?: string;
+    /** Confirmation prompt before deleting a single conversation. */
+    deleteConversationConfirm?: string;
+    /** Confirmation prompt before deleting every conversation in the active scope. */
+    clearHistoryConfirm?: string;
+    /** Confirmation prompt before detaching this browser from its history identity. */
+    resetIdentityConfirm?: string;
+    /** Label for the action that starts a new server conversation. */
+    newConversationLabel?: string;
+    /** Label for the action that prepends the previous transcript page. */
+    showEarlierMessagesLabel?: string;
+    /** Accessible label for the transcript skeleton while a conversation loads. */
+    openConversationLoadingLabel?: string;
+    /** Body text when a selected conversation failed to load. */
+    openConversationErrorTitle?: string;
+    /** Label for the retry action after a conversation failed to load. */
+    openConversationRetryLabel?: string;
+    /** Label for the return-to-messages action after a conversation failed to load. */
+    openConversationBackLabel?: string;
+    /** Status notice after a deleted conversation was recovered into a fresh one. */
+    conversationDeletedNotice?: string;
+    /** Status notice after this browser was detached from its history identity. */
+    identityResetNotice?: string;
+    /** Status notice when a local reset succeeded but server revocation was unconfirmed. */
+    identityResetUnconfirmedNotice?: string;
+    /** Pinned group heading for starred conversations. */
+    groupStarred?: string;
+    /** Time-group heading for conversations updated today. */
+    groupToday?: string;
+    /** Time-group heading for conversations updated yesterday. */
+    groupYesterday?: string;
+    /** Time-group heading for the trailing 7-day window. */
+    groupPrevious7Days?: string;
+    /** Time-group heading for the trailing 30-day window. */
+    groupPrevious30Days?: string;
+    /** Time-group heading for older conversations, grouped by month and year. */
+    groupMonthYear?: string;
+    /** Scope title when history is limited to this browser. */
+    browserOnlyTitle?: string;
+    /** Scope description when history is limited to this browser. */
+    browserOnlyDescription?: string;
+    /** Scope title while an identity proof is being resolved. */
+    verifyingTitle?: string;
+    /** Scope description while an identity proof is being resolved. */
+    verifyingDescription?: string;
+    /** Scope title when history is available across signed-in devices. */
+    verifiedTitle?: string;
+    /** Scope description when history is available across signed-in devices. */
+    verifiedDescription?: string;
+    /** Scope title when the visitor must sign in again to view account history. */
+    authenticationRequiredTitle?: string;
+    /** Scope description when the visitor must sign in again to view account history. */
+    authenticationRequiredDescription?: string;
+    /** Scope title when the host identity provider threw or rejected. */
+    identityProviderFailedTitle?: string;
+    /** Scope description when the host identity provider threw or rejected. */
+    identityProviderFailedDescription?: string;
+    /** Scope title when the server did not admit a supplied identity proof. */
+    proofNotAdmittedTitle?: string;
+    /** Scope description when the server did not admit a supplied identity proof. */
+    proofNotAdmittedDescription?: string;
+    /** Label for the action that retries identity resolution. */
+    retryIdentityLabel?: string;
+    /** Accessible name of the header control that opens history. */
+    openHistoryLabel?: string;
+    /** Accessible name of that control while a turn is streaming or resuming. */
+    openHistoryBusyLabel?: string;
+    /** Least-destructive action in every history confirmation dialog. */
+    confirmCancelLabel?: string;
+    /** Heading of the delete-one confirmation. */
+    deleteConversationConfirmTitle?: string;
+    /** Confirming action of the delete-one confirmation. */
+    deleteConversationConfirmLabel?: string;
+    /** Heading of the delete-all confirmation. */
+    clearHistoryConfirmTitle?: string;
+    /** Confirming action of the delete-all confirmation. */
+    clearHistoryConfirmLabel?: string;
+    /** Delete-all body used when the resolved scope is the signed-in user. */
+    clearHistoryVerifiedConfirm?: string;
+    /** Heading of the forget-this-device confirmation. */
+    resetIdentityConfirmTitle?: string;
+    /** Confirming action of the forget-this-device confirmation. */
+    resetIdentityConfirmLabel?: string;
+    /** Panel back control; returns to the surface that opened Messages. */
+    backLabel?: string;
+    /** Rail close control, shown only when the rail is not collapsible. */
+    closeLabel?: string;
+    /** Rail collapse toggle while the rail is expanded. */
+    collapseLabel?: string;
+    /** Rail collapse toggle while the rail is collapsed to icons. */
+    expandLabel?: string;
+    /** Accessible name of the docked rail's drag-resize handle. */
+    resizeLabel?: string;
+    /** Accessible status while the first page loads. */
+    loadingLabel?: string;
+    /** Label of the paging action below the last group. */
+    loadMoreLabel?: string;
+    /** Label of that action while its page is in flight. */
+    loadingMoreLabel?: string;
+    /**
+     * Heading over the conversation list. Visible in rail presentation, where it
+     * carries the list overflow trigger; sr-only in panel presentation.
+     */
+    conversationsTitle?: string;
+    /** Accessible name of the per-row overflow trigger and its menu. */
+    rowActionsLabel?: string;
+    /** Accessible name of the list-level overflow trigger and its menu. */
+    listOptionsLabel?: string;
+    /** Delete item inside the per-row overflow menu. */
+    deleteConversationLabel?: string;
+    /** Delete-all item inside the list overflow menu. */
+    clearHistoryLabel?: string;
+    /** Forget-this-device item inside the list overflow menu. */
+    resetIdentityLabel?: string;
+    /** Row message count. `{count}` placeholder. */
+    messageCountLabel?: string;
+    /** Row message count for exactly one message. */
+    messageCountLabelOne?: string;
+    /** Announced after a single conversation was deleted. */
+    conversationRemovedNotice?: string;
+    /** Announced after every conversation in scope was deleted. */
+    historyClearedNotice?: string;
+    /** Heading shown when history is unavailable for this surface. */
+    unavailableTitle?: string;
+    /** Body text shown when history is unavailable for this surface. */
+    unavailableDescription?: string;
+    /** Heading of the post-deletion replacement-init recovery state. */
+    newConversationRequiredTitle?: string;
+    /** Body text of the post-deletion replacement-init recovery state. */
+    newConversationRequiredDescription?: string;
+    /** Rate-limited wait guidance. `{seconds}` placeholder. */
+    rateLimitedWaitDescription?: string;
+    /** Row-adjacent error after a failed open. */
+    openFailedLabel?: string;
+    /** Row-adjacent error after a failed delete. */
+    deleteFailedLabel?: string;
+    /** Relative time for the most recent bucket. */
+    relativeNow?: string;
+    /** Relative time in minutes. `{value}` placeholder. */
+    relativeMinutes?: string;
+    /** Relative time in hours. `{value}` placeholder. */
+    relativeHours?: string;
+    /** Relative time in days. `{value}` placeholder. */
+    relativeDays?: string;
+    /** Relative time in weeks. `{value}` placeholder. */
+    relativeWeeks?: string;
+    /** Relative time in years. `{value}` placeholder. */
+    relativeYears?: string;
+}
+/**
+ * Host-defined item in the list overflow menu (the `…` beside the
+ * conversation-list heading). Rendered above the built-in destructive items.
+ */
+interface AgentWidgetHistoryListAction {
+    /** Stable identity; keeps menu focus keys stable across re-renders. */
+    id: string;
+    label: string;
+    /** Destructive (red) styling like the built-in delete-all. Default false. */
+    danger?: boolean;
+    /** Receives the conversation summaries loaded at selection time. */
+    onSelect: (context: {
+        conversations: HistoryConversationSummary[];
+    }) => void | Promise<void>;
+}
+/** Resolved scope for a logical history operation. */
+type HistoryScope = "browser" | "verified-user";
+/**
+ * Evidence-based history identity state. Never inferred from the mere presence
+ * of `getIdentityProof`, and never carries token, visitor, or end-user values.
+ */
+type HistoryIdentityStatus = {
+    state: "browser_only";
+    reason: "configured_browser_scope" | "no_identity_provider" | "proof_unavailable_before_binding";
+} | {
+    state: "verifying";
+} | {
+    state: "verified";
+} | {
+    state: "authentication_required";
+    reason: "proof_unavailable_after_binding" | "invalid_identity_proof";
+} | {
+    state: "identity_provider_failed";
+} | {
+    state: "configuration_error";
+    reason: "proof_not_admitted";
+} | {
+    state: "resetting";
+} | {
+    state: "unavailable";
+    reason: "history_disabled" | "ineligible_mode";
+};
+/**
+ * Every history operation a render hook may invoke. Each routes through the
+ * same controller/session path as the default renderer, so busy gating,
+ * selection epochs, and confirmations behave identically.
+ */
+type AgentWidgetHistoryRenderActions = {
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+    openConversation(conversationId: string): Promise<void>;
+    startNewConversation(): Promise<void>;
+    /** Each request method opens Persona's accessible confirmation first. */
+    requestDeleteConversation(conversationId: string): Promise<"deleted" | "cancelled">;
+    requestClearConversationHistory(): Promise<"cleared" | "cancelled">;
+    requestResetHistoryIdentity(): Promise<{
+        outcome: "cancelled";
+    } | {
+        outcome: "reset";
+        remoteRevocationConfirmed: boolean;
+    }>;
+    close(): void;
+};
+/**
+ * One conversation row, normalized at the Runtype boundary. The deprecated wire
+ * `flowId` alias never escapes that boundary: history code reads `targetId`.
+ */
+type HistoryConversationSummary = {
+    id: string;
+    /** Server-generated; rendered verbatim, never derived locally. */
+    title: string;
+    /** Resolved chat target (flow or agent); `null` when the server omits it. */
+    targetId: string | null;
+    /** Server-produced plain-text preview; `null` when unavailable. */
+    preview: string | null;
+    messageCount: number;
+    createdAt: string;
+    updatedAt: string;
+    /** Visitor-pinned flag. Absent when the provider has no update capability. */
+    starred?: boolean;
+};
+/** Visitor-editable conversation metadata. Absent fields are left unchanged. */
+type HistoryConversationPatch = {
+    title?: string;
+    starred?: boolean;
+};
+type AgentWidgetMessageRole = "user" | "assistant" | "system";
+type AgentWidgetReasoning = {
+    id: string;
+    status: "pending" | "streaming" | "complete";
+    chunks: string[];
+    /**
+     * Reasoning channel scope (wire spec). `"turn"` is ordinary per-turn
+     * thinking; `"loop"` is a cross-iteration agent reflection (the fold that
+     * replaced the legacy `agent_reflection` event). Absent for legacy streams.
+     */
+    scope?: "turn" | "loop";
+    startedAt?: number;
+    completedAt?: number;
+    durationMs?: number;
+};
+type AgentWidgetToolCall = {
+    id: string;
+    name?: string;
+    status: "pending" | "running" | "complete";
+    args?: unknown;
+    chunks?: string[];
+    result?: unknown;
+    duration?: number;
+    startedAt?: number;
+    completedAt?: number;
+    durationMs?: number;
+};
+/**
+ * Represents a tool approval request in the chat conversation.
+ * Created when the agent requires human approval before executing a tool.
+ */
+type AgentWidgetApproval = {
+    id: string;
+    status: "pending" | "approved" | "denied" | "timeout";
+    agentId: string;
+    executionId: string;
+    toolName: string;
+    toolType?: string;
+    description: string;
+    /**
+     * Agent-authored justification for this specific call (the agent's own
+     * claim about its intent, extracted server-side from the reserved
+     * `_approvalReason` parameter). Render it attributed to the agent and as
+     * plain text: it is approver context, not a system statement.
+     */
+    reason?: string;
+    parameters?: unknown;
+    resolvedAt?: number;
+};
+type AgentWidgetMessageVariant = "assistant" | "reasoning" | "tool" | "approval";
+/**
+ * Per-turn / per-step stop reason emitted by the runtime on
+ * `agent_turn_complete` and `step_complete` SSE events. The vocabulary is
+ * owned by the upstream Runtype API: do not extend without coordination.
+ *
+ * - `end_turn`: natural completion (no affordance needed)
+ * - `max_tool_calls`: agent loop tripped the configured tool-call ceiling
+ * - `length`: provider hit max output tokens
+ * - `content_filter`: provider content filter intervened
+ * - `error`: provider/runtime error (prefer existing error rendering)
+ * - `unknown`: explicitly reported but uninformative
+ *
+ * Absent (`undefined`) means "not reported": distinct from `'unknown'`.
+ */
+type StopReasonKind = RuntypeStopReasonKind;
+/**
+ * Represents a message in the chat conversation.
+ *
+ * @property id - Unique message identifier
+ * @property role - Message role: "user", "assistant", or "system"
+ * @property content - Message text content (for display)
+ * @property contentParts - Original multi-modal content parts (for API requests)
+ * @property createdAt - ISO timestamp when message was created
+ * @property streaming - Whether message is still streaming (for assistant messages)
+ * @property variant - Message variant for assistant messages: "assistant", "reasoning", or "tool"
+ * @property sequence - Message ordering number
+ * @property reasoning - Reasoning data for assistant reasoning messages
+ * @property toolCall - Tool call data for assistant tool messages
+ * @property tools - Array of tool calls
+ * @property viaVoice - Set to `true` when a user message is sent via voice recognition.
+ *                      Useful for implementing voice-specific behaviors like auto-reactivation.
+ */
+type AgentWidgetMessage = {
+    id: string;
+    role: AgentWidgetMessageRole;
+    content: string;
+    createdAt: string;
+    /**
+     * Original multi-modal content parts for this message.
+     * When present, this is sent to the API instead of `content`.
+     * The `content` field contains the text-only representation for display.
+     */
+    contentParts?: ContentPart[];
+    /**
+     * Context mentions attached to this (user) message, for transcript fidelity +
+     * chip rendering in the sent bubble. Refs only — the resolved payloads are
+     * merged into `llmContent`/`contentParts` (model-visible) at send time.
+     */
+    contextMentions?: AgentWidgetContextMentionRef[];
+    /**
+     * Ordered prose + mention blocks for inline-mode rendering and composer history
+     * recall (`contextMentions.display: "inline"`). Present only on inline-mode user
+     * messages; when omitted the sent bubble falls back to the chip row derived from
+     * `contextMentions`. Display/transcript concern only — not the model channel.
+     */
+    contentSegments?: AgentWidgetContentSegment[];
+    /**
+     * Resolved opt-in structured mention context for this (user) message, merged
+     * into the request `context` under `mentions.<sourceId>.<itemId>` by the
+     * client. Internal: set at send time from each source's `resolve().context`.
+     */
+    mentionContext?: Record<string, unknown>;
+    streaming?: boolean;
+    variant?: AgentWidgetMessageVariant;
+    sequence?: number;
+    reasoning?: AgentWidgetReasoning;
+    toolCall?: AgentWidgetToolCall;
+    tools?: AgentWidgetToolCall[];
+    /** Approval data for messages with variant "approval" */
+    approval?: AgentWidgetApproval;
+    viaVoice?: boolean;
+    /**
+     * Set to `true` on placeholder messages injected during Runtype voice processing.
+     * Use this in `messageTransform` to detect and customize voice processing placeholders.
+     *
+     * @example
+     * messageTransform: ({ text, message }) => {
+     *   if (message.voiceProcessing && message.role === 'user') {
+     *     return '<div class="my-voice-spinner">Transcribing...</div>';
+     *   }
+     *   return text;
+     * }
+     */
+    voiceProcessing?: boolean;
+    /**
+     * Raw structured payload for this message (e.g., JSON action response).
+     * Populated automatically when structured parsers run.
+     */
+    rawContent?: string;
+    /**
+     * LLM-specific content for API requests.
+     * When present, this is sent to the LLM instead of `content`.
+     *
+     * Priority for API payload:
+     * 1. `contentParts` (if present, used as-is for multi-modal)
+     * 2. `llmContent` (if present, sent as string)
+     * 3. `rawContent` (backward compatibility with structured parsers)
+     * 4. `content` (fallback - display content)
+     *
+     * The `content` field is always used for UI display.
+     *
+     * @example
+     * // Show full details to user, send summary to LLM
+     * {
+     *   content: "**Product:** iPhone 15 Pro\n**Price:** $1,199\n**SKU:** IP15P-256",
+     *   llmContent: "[Product search: iPhone 15 Pro, $1199]"
+     * }
+     */
+    llmContent?: string;
+    /**
+     * Text segment identity for chronological ordering.
+     * When present, identifies which text segment this message represents
+     * (e.g., "text_0", "text_1") for messages split at tool boundaries.
+     */
+    partId?: string;
+    /**
+     * Metadata for messages created during agent loop execution.
+     * Contains execution context like iteration number and turn ID.
+     */
+    agentMetadata?: AgentMessageMetadata;
+    /**
+     * Per-turn stop reason reported by the runtime on `agent_turn_complete`
+     * (agent-loop path) or the last `step_complete` for a prompt step
+     * (dispatch / flow path). Absent when the API did not report a value.
+     *
+     * When set to a non-natural value (`max_tool_calls`, `length`,
+     * `content_filter`, `error`), the widget renders an inline notice on
+     * the assistant bubble. See `config.copy.stopReasonNotice` to override
+     * the default copy.
+     */
+    stopReason?: StopReasonKind;
+};
+
+/**
+ * Resolved copy for the history ("Messages") view.
+ *
+ * `AgentWidgetHistoryCopy` (types.ts) is the single authoritative
+ * host-overridable type; the defaults live here, in the chunk. The handful of
+ * strings the shell must render before this chunk loads come from
+ * `components/history-shell-copy.ts` so each key still has one default.
+ *
+ * House style: sentence case, no em-dashes, no all-caps.
+ */
+
+type HistoryViewCopyInput = AgentWidgetHistoryCopy;
+type ResolvedHistoryViewCopy = Required<AgentWidgetHistoryCopy>;
+declare const HISTORY_VIEW_COPY_DEFAULTS: ResolvedHistoryViewCopy;
+/** Idempotent: safe to call on an already-resolved copy object. */
+declare function resolveHistoryViewCopy(copy: HistoryViewCopyInput | undefined): ResolvedHistoryViewCopy;
+
+/**
+ * Client-side time grouping and relative-time formatting for the Messages list.
+ *
+ * Grouping never reorders: it walks the server order and opens a new group
+ * whenever the resolved key changes, so an appended page merges into the
+ * trailing group when its first item shares that group's key.
+ */
+
+/** `features.history.grouping`. Starred rows keep their pinned group in both. */
+type HistoryGroupingMode = "time" | "none";
+
+/**
+ * Conversation row + its overflow menu.
+ *
+ * The row is a whole-row button; the overflow trigger is a SIBLING absolutely
+ * positioned over it, because a button cannot legally nest inside a button.
+ *
+ * Hierarchy: avatar, then title over preview with the relative time aligned to
+ * the title. A conversation without a server title promotes its preview to the
+ * title line rather than rendering an empty one; nothing is derived locally.
+ */
+
+type RowPending = "opening" | "deleting" | null;
+
+/**
+ * List-region state model plus its DOM. These blocks replace the LIST only:
+ * the top bar, the primary new-conversation action, and the destructive footer
+ * are built once and never move between states.
+ */
+
+type HistoryListErrorReason = "unavailable" | "authentication_failed" | "authentication_required" | "identity_provider_failed" | "proof_not_admitted" | "unsupported_scope" | "unknown";
+type HistoryListState = {
+    kind: "loading";
+    phase: "initial" | "refresh" | "load-more";
+} | {
+    kind: "ready";
+} | {
+    kind: "empty";
+} | {
+    kind: "error";
+    reason: HistoryListErrorReason;
+    retryable: boolean;
+} | {
+    kind: "rate_limited";
+    retryAfterSeconds: number;
+} | {
+    kind: "new_conversation_required";
+};
+
+/**
+ * History ("Messages") navigation view — the default visitor-facing surface
+ * described in `docs/visitor-history-implementation-plan.md` D7.
+ *
+ * Scope split: this file owns the VIEW (list, grouping, paging, list-region
+ * states, row/menu affordances, its own announcements and styles). The shell
+ * owns placement, open/close, inertness of the obscured conversation, focus
+ * orchestration between surfaces, confirmations, and every session mutation —
+ * the view only invokes the callbacks below and awaits their promises.
+ *
+ * Never statically imported on the core path: the IIFE build marks
+ * `@runtypelabs/persona/history-view` external and `build:client` marks the same
+ * subpath external for ESM/CJS. The core reaches it through
+ * `history-view-loader.ts`. Guarded by `history-view-bundle.test.ts`.
+ */
+
+type HistoryViewPresentation = "panel" | "rail";
+/**
+ * Where the top bar's contents live. `"external"` hands them to the shell,
+ * which mounts them inside its own persistent header; the view element then
+ * starts at the body.
+ */
+type HistoryHeaderPlacement = "inline" | "external";
+type HistoryViewPendingAction = {
+    kind: "refresh" | "load-more" | "start-new" | "clear" | "reset";
+} | {
+    kind: "open" | "delete";
+    conversationId: string;
+} | null;
+/**
+ * Slot seams for the core arbitration layer (`history-render.ts`). The public
+ * plugin contexts are built there: the view only supplies the slot's data and
+ * its own default DOM, and never sees a plugin.
+ */
+interface HistoryHeaderSlotContext {
+    identityStatus: HistoryIdentityStatus;
+    pendingAction: HistoryViewPendingAction;
+    copy: ResolvedHistoryViewCopy;
+    defaultRenderer: () => HTMLElement;
+}
+interface HistoryConversationSlotContext {
+    conversation: HistoryConversationSummary;
+    active: boolean;
+    pending: RowPending;
+    open: () => Promise<void>;
+    requestDelete: () => Promise<"deleted" | "cancelled">;
+    defaultRenderer: () => HTMLElement;
+}
+interface HistoryStateSlotContext {
+    state: Exclude<HistoryListState, {
+        kind: "ready";
+    }>;
+    identityStatus: HistoryIdentityStatus;
+    copy: ResolvedHistoryViewCopy;
+    retry?: () => Promise<void>;
+    startNewConversation?: () => Promise<void>;
+    defaultRenderer: () => HTMLElement;
+}
+interface HistoryViewSlotRenderers {
+    header?: (context: HistoryHeaderSlotContext) => HTMLElement | null;
+    conversation?: (context: HistoryConversationSlotContext) => HTMLElement | null;
+    state?: (context: HistoryStateSlotContext) => HTMLElement | null;
+}
+/** Snapshot source for the core arbitration layer. Read-only by contract. */
+interface HistoryViewModel {
+    conversations: readonly HistoryConversationSummary[];
+    activeConversationId: string | null;
+    state: HistoryListState;
+    pendingAction: HistoryViewPendingAction;
+    identityStatus: HistoryIdentityStatus;
+    nextCursor: string | null;
+}
+/**
+ * The operations the default DOM invokes. Shaped as the public render actions
+ * minus `close` (the shell owns that) so the core can forward them verbatim.
+ */
+type HistoryViewOperations = Omit<AgentWidgetHistoryRenderActions, "close">;
+/** Where a rail section sits relative to the built-in conversation list. */
+type HistoryRailSectionPlacement = "above-conversations" | "below-conversations" | "footer";
+/** Core-normalized rail nav item: one label, one pre-resolved icon, one action. */
+interface HistoryRailSectionItem {
+    id: string;
+    label: string;
+    badge?: string;
+    /** Memoized by the core, so a presentation flip reuses the same node. */
+    iconNode?: () => Element | null;
+    /** Already guarded by the core; this chunk calls it bare. */
+    onSelect: () => void;
+}
+interface HistoryRailSection {
+    id: string;
+    title?: string;
+    placement: HistoryRailSectionPlacement;
+    items: HistoryRailSectionItem[];
+    /**
+     * Plugin-backed body, in place of `items`. Re-invoked with each new collapsed
+     * value; null empties and hides the section, as does a throw after one warn.
+     */
+    render?: (collapsed: boolean) => Element | null;
+}
+interface HistoryViewOptions {
+    /** Internal seam (D9). The view never touches `AgentWidgetClient`. */
+    provider: HistoryProvider;
+    /** Resolved once when history opens; reused by every operation. */
+    context: HistoryOperationContext;
+    /** Canonical active target filter. `null` lists the whole authorized scope. */
+    targetId: string | null;
+    /** Host overrides; defaults are applied here, so passing a partial is fine. */
+    copy?: HistoryViewCopyInput;
+    /** Already resolved against the host container width by the shell, not here. */
+    presentation: HistoryViewPresentation;
+    /**
+     * Rail only. Default true: the bar's leading control is a collapse toggle
+     * instead of a close (x), and `onToggleCollapse` drives it.
+     */
+    collapsible?: boolean;
+    /** Rail only. Initial collapsed state; the shell owns and persists it. */
+    collapsed?: boolean;
+    /**
+     * Rail only. The edge the rail docks to, so the bar can put its collapse
+     * toggle on the inner edge facing the conversation. Default `"left"`.
+     */
+    railSide?: "left" | "right";
+    /**
+     * Rail only. Host-rendered identity for the bar's heading area. The `h2`
+     * stays in the DOM as sr-only, so the region keeps its accessible name.
+     */
+    renderRailHeader?: (context: {
+        collapsed: boolean;
+        defaultTitle: string;
+    }) => Element | null;
+    /**
+     * Rail only. Core-resolved brand mark for both identity spots: the heading
+     * default composition (`false`) and the collapsed toggle's rest face
+     * (`true`). Null means no brand for that spot. Outranked by
+     * `renderRailHeader` in the heading.
+     */
+    railBrand?: (collapsed: boolean) => Element | null;
+    /**
+     * Rail only. Host navigation sections stacked around the conversation list.
+     * Normalized by the core, which also resolves each item's icon precedence
+     * into `iconNode` so this chunk never imports the lucide registry.
+     */
+    railSections?: HistoryRailSection[];
+    /**
+     * Rail only. Pre-formatted collapse shortcut: `hint` is the tooltip chip,
+     * `aria` the `aria-keyshortcuts` value. The shell owns the binding and both
+     * strings, so this chunk never bundles the shortcut module.
+     */
+    collapseShortcut?: {
+        hint: string;
+        aria: string;
+    };
+    /** Default `"inline"`. Rail is always inline; the shell enforces that. */
+    headerPlacement?: HistoryHeaderPlacement;
+    showScopeStatus: boolean;
+    /**
+     * Per-row delete via the row overflow menu. Default true; false drops the
+     * trigger (delete is its only item). Hides the control only — custom row
+     * slots still receive `requestDelete`.
+     */
+    showDelete?: boolean;
+    /** The list overflow menu's clear-history item. Default true. */
+    showDeleteAll?: boolean;
+    /** Host items in the list overflow menu, above the built-in destructive ones. */
+    listActions?: AgentWidgetHistoryListAction[];
+    /**
+     * Leading row avatar: an image URL, a glyph, or `false` to omit the block.
+     * Absent falls back to the same glyph the header uses.
+     */
+    rowAvatar?: string | false;
+    activeConversationId: string | null;
+    /**
+     * Date bucketing of the list. Default `"time"`; `"none"` folds the time
+     * buckets into one flat group. Starred rows keep their pinned group either
+     * way.
+     */
+    grouping?: HistoryGroupingMode;
+    /** List page size. Default 25. */
+    pageSize?: number;
+    /** Clock seam for grouping and relative time. */
+    now?: () => number;
+    /** Row selection. The shell commits the open; the view shows row pending. */
+    onSelect: (conversationId: string) => void | Promise<void>;
+    onStartNew: () => void | Promise<void>;
+    /** Back (panel) or close (rail without a collapse toggle). */
+    onClose: () => void;
+    /** Collapse toggle. The shell decides, then calls `setCollapsed`. */
+    onToggleCollapse?: () => void;
+    /** Shell owns the confirmation; resolves with the outcome. */
+    onRequestDeleteConversation: (conversationId: string) => Promise<"deleted" | "cancelled">;
+    onRequestClearHistory: () => Promise<"cleared" | "cancelled">;
+    /** Rendered only when the provider exposes `resetDevice`. */
+    onRequestResetIdentity?: () => Promise<{
+        outcome: "cancelled";
+    } | {
+        outcome: "reset";
+        remoteRevocationConfirmed: boolean;
+    }>;
+    /** Core-owned plugin slots. Absent means the default DOM everywhere. */
+    slots?: HistoryViewSlotRenderers;
+    /**
+     * Start with DOM rendering suspended so the core can arbitrate a full-view
+     * hook before any slot runs. Default true.
+     */
+    renderDom?: boolean;
+    /** Model-change signal, emitted only while DOM rendering is suspended. */
+    onModelChange?: () => void;
+    /**
+     * Fired whenever the ACTIVE conversation's list summary changes: on
+     * selection, on a list refresh that delivers a server-generated title, on a
+     * rename/star patch, and with `null` when no active conversation is listed.
+     * Feeds the shell's `layout.header.titleSource: "conversation"` binding and
+     * its built-in title-menu star toggle.
+     */
+    onActiveConversationChange?: (summary: HistoryConversationSummary | null) => void;
+    /** Shell live region, used while this view's own one is detached. */
+    onAnnounce?: (message: string) => void;
+    /**
+     * The shell's tooltip attacher, passed in so the size-capped chunk never
+     * bundles a second copy of the tooltip module. Absent means no tooltips.
+     */
+    attachTooltip?: (options: TooltipOptions) => TooltipHandle;
+}
+interface HistoryViewHandle {
+    element: HTMLElement;
+    /** Resolved copy, defaults included. The defaults live in this chunk. */
+    copy: ResolvedHistoryViewCopy;
+    /** Immutable-by-contract model snapshot for the core arbitration layer. */
+    getModel(): HistoryViewModel;
+    /** The same operations the default DOM invokes, for public render hooks. */
+    operations: HistoryViewOperations;
+    /** Suspend/resume this view's DOM while a plugin owns the full surface. */
+    setDomRenderEnabled(enabled: boolean): void;
+    /** Re-fetch and re-render the list in place, preserving list/focus state. */
+    refresh(): void;
+    /**
+     * Retarget the view when the shell moves it between hosts (rail <-> panel).
+     * The instance and all its state survive the move; only chrome changes.
+     */
+    setPresentation(presentation: HistoryViewPresentation): void;
+    /**
+     * Collapse the rail to its icon column. The view only styles itself and
+     * relabels the toggle; the shell owns the host width and the persisted state.
+     */
+    setCollapsed(collapsed: boolean): void;
+    /** Re-mirror the bar for a live `rail.side` change. */
+    setRailSide(side: "left" | "right"): void;
+    /**
+     * The top bar's CURRENT content node (the default bar or a slot replacement).
+     * A slot re-render swaps it in place, so an external host stays its parent.
+     */
+    getHeaderElement(): HTMLElement;
+    /**
+     * Hand the bar's contents to the shell (`"external"`, detached for the shell
+     * to re-home) or take them back (`"inline"`). Idempotent; never replays the
+     * entrance.
+     */
+    setHeaderPlacement(placement: HistoryHeaderPlacement): void;
+    /** Keep the active-row indicator in sync when the shell changes conversation. */
+    setActiveConversationId(conversationId: string | null): void;
+    /** Patch one listed summary in place after a shell-side rename/star. */
+    applyConversationSummary(summary: HistoryConversationSummary): void;
+    /** Drop one listed row after a shell-side delete (headless or built-in). */
+    removeConversationSummary(conversationId: string): void;
+    /** Enter/leave the post-deletion replacement-init recovery state. */
+    setNewConversationRequired(required: boolean): void;
+    /**
+     * Mirrored exit for the shell's close sequence. Resolves once the surface has
+     * visually left; never rejects, and repeat calls join the running exit.
+     * `null` means nothing to wait for (motion off, or no WAAPI): the caller must
+     * tear down synchronously rather than deferring by a microtask.
+     */
+    playExit(): Promise<void> | null;
+    destroy(): void;
+}
+declare function createHistoryView(options: HistoryViewOptions): HistoryViewHandle;
+
+export { HISTORY_VIEW_COPY_DEFAULTS, type HistoryListErrorReason, type HistoryListState, type HistoryViewCopyInput, type HistoryViewHandle, type HistoryViewOptions, type HistoryViewPendingAction, type HistoryViewPresentation, type ResolvedHistoryViewCopy, createHistoryView, resolveHistoryViewCopy };