@hydraharness/harness-client-ui-conversation 0.1.1-rc.6

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

@@ -0,0 +1,220 @@
+/**
+ * Scope-addressed conversation send, cancel, and history orchestration.
+ *
+ * Scope addressing rides the cordis Service tracker: property access through
+ * `ctx.conversation` rebinds `this.ctx` to the caller's context, so methods
+ * read the session tag with `scopeOf`. Mutable state must remain reachable
+ * through one property read; assignment through the tracker proxy and `#`
+ * private fields bypass that rebinding.
+ */
+import { Service } from '@hydraharness/cordis';
+import type { Context } from '@hydraharness/cordis';
+import type { SessionFace, SessionId } from '@hydraharness/harness-client-runtime/client';
+import type { SubmitImageAttachment, SubmitOutcome } from '@hydraharness/harness-client-ui-input-trigger/client';
+import type { ImageAttachmentRef, VideoAttachmentRef } from '@hydraharness/harness-attachment';
+import type { BrowserAnnotationAttachment, ComposerAttachment } from './contract/slots.ts';
+import type { QueueAction, QueueItemId } from './contract/queue.ts';
+import type { ComposerBlocks } from './input/blocks.ts';
+import type { DraftAttachmentId, SessionInputResolver } from './input/contract.ts';
+import type { InputSubmitMode } from './contract/composer-submission.ts';
+/**
+ * The outward conversation face (`ctx.conversation`): the scope-addressed
+ * verbs and the input registry other plugins may reach — and exactly what a
+ * test fake must supply.
+ */
+export interface IConversation {
+    /** The per-session input machine registry (SessionInputResolver face). */
+    readonly input: SessionInputResolver;
+    /**
+     * The per-session composer-block registry: how a plugin the composer
+     * cannot import makes a session's input inert with its own reason.
+     */
+    readonly blocks: ComposerBlocks;
+    /**
+     * Send a prompt into the caller scope's session (queued turn).
+     * @param text - prompt text, sent verbatim as one text block.
+     * @returns completion; business failures reject (and land in promptError).
+     */
+    send(text: string): Promise<void>;
+    /**
+     * Apply one edit, remove, or strict steer operation to a pending queue occurrence.
+     * @param itemId - agent-owned inbox occurrence identity.
+     * @param action - requested queue operation.
+     * @returns completion; converged strict-steer races resolve, while other failures reject.
+     */
+    updateQueue(itemId: QueueItemId, action: QueueAction): Promise<void>;
+    /**
+     * Cancel the scoped session's in-flight turn while preserving its pending Queue.
+     * @returns completion; failures reject as in send.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Pull one older history page for the scoped session.
+     * @returns completion of the page pull.
+     */
+    loadOlder(): Promise<void>;
+}
+interface BrowserAnnotationBase {
+    readonly url: string;
+    readonly title: string;
+    readonly preview: string;
+}
+interface BrowserAnnotationRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** One bounded element or viewport-region selection received from Browser. */
+export type BrowserAnnotationSelection = BrowserAnnotationBase & ({
+    readonly kind: 'browser-element';
+    readonly index?: number;
+    readonly rect?: BrowserAnnotationRect;
+} | {
+    readonly kind: 'browser-region';
+    readonly rect: BrowserAnnotationRect;
+    readonly index?: never;
+});
+/** Browser-owned annotation file waiting in the current composer. */
+export type DraftBrowserAnnotation = BrowserAnnotationAttachment;
+/** Unsupported browser-declared image type, localized by the UI boundary. */
+export declare class UnsupportedImageMediaTypeError extends Error {
+    /** Browser-declared MIME value, possibly empty. */
+    readonly mediaType: string;
+    /** @param mediaType - Browser-declared MIME value, possibly empty. */
+    constructor(mediaType: string);
+}
+/** Scope-addressed conversation service (root singleton, provided as `conversation`). */
+export declare class ConversationController extends Service implements IConversation {
+    /** The per-session input machine registry (SessionInputResolver face). */
+    readonly input: SessionInputResolver;
+    /** The per-session composer-block registry. */
+    readonly blocks: ComposerBlocks;
+    private readonly draftAttachments;
+    private readonly imageUrls;
+    private readonly imageGenerations;
+    private readonly createdImageUrls;
+    private disposed;
+    /**
+     * @param ctx - owning root context (the plugin apply context; the service
+     * registers itself and follows that fiber's lifetime).
+     * @param config - carries the SessionInputResolver and composer-block registry
+     * constructed by the plugin apply (the same instances the slot inject
+     * factories close over).
+     */
+    constructor(ctx: Context, config: {
+        input: SessionInputResolver;
+        blocks: ComposerBlocks;
+    });
+    /**
+     * Send a prompt into the scoped session. Business failures also land in the
+     * session snapshot's promptError (object-layer state); the rejection here
+     * exists for caller choreography (the composer restores the draft on it).
+     * @param text - prompt text, sent verbatim as one text block.
+     */
+    send(text: string): Promise<void>;
+    /**
+     * Submit ordered draft images with text through one host admission.
+     * @param session - target session.
+     * @param text - serialized prompt text.
+     * @param imageIds - ordered draft-local attachment ids.
+     * @param mode - queue or steer delivery selected by composer policy.
+     * @param signal - optional cancellation for the complete Host admission.
+     * @param browserAnnotationIds - ordered draft-local browser annotation ids.
+     * @returns the Host admission outcome; local attachment preparation failures reject.
+     */
+    sendSession(session: SessionFace, text: string, imageIds: readonly DraftAttachmentId[], mode: InputSubmitMode, signal?: AbortSignal, browserAnnotationIds?: readonly DraftAttachmentId[]): Promise<SubmitOutcome>;
+    /**
+     * Create runtime-only draft images and their object URLs.
+     * @param files - browser files to register after MIME validation.
+     * @returns ordered draft descriptors.
+     */
+    createDraftImages(files: readonly File[]): readonly ComposerAttachment[];
+    /**
+     * Create one browser-selected text attachment without touching the draft string.
+     * @param annotation - bounded Browser selection metadata and optional image.
+     * @param comment - user comment carried with the attachment.
+     * @returns the runtime-owned draft attachment.
+     */
+    createDraftBrowserAnnotation(annotation: BrowserAnnotationSelection, comment?: string): DraftBrowserAnnotation;
+    /** Pair a browser annotation with its optional screenshot draft image.
+     * @param annotationId - Browser annotation draft to update.
+     * @param screenshotId - Screenshot draft attached to the annotation.
+     */
+    attachDraftBrowserAnnotationScreenshot(annotationId: DraftAttachmentId, screenshotId: DraftAttachmentId): void;
+    /**
+     * Resolve ordered input-state ids to runtime-owned draft images.
+     * @param ids - draft attachment ids.
+     * @returns descriptors that remain live, in requested order.
+     */
+    draftImages(ids: readonly DraftAttachmentId[]): readonly ComposerAttachment[];
+    /**
+     * Resolve ordered input-state ids to browser-selected text attachments.
+     * @param ids - draft attachment ids.
+     * @returns descriptors that remain live, in requested order.
+     */
+    draftBrowserAnnotations(ids: readonly DraftAttachmentId[]): readonly DraftBrowserAnnotation[];
+    /**
+     * Update the user comment carried with one browser annotation attachment.
+     * @param id - draft attachment id.
+     * @param comment - replacement user comment.
+     */
+    updateDraftBrowserAnnotationComment(id: DraftAttachmentId, comment: string): void;
+    /**
+     * Serialize ordered draft images to command-submit wire payloads without
+     * sending or releasing them (the composer releases only after the command
+     * settles successfully).
+     * @param imageIds - ordered draft-local attachment ids.
+     * @returns base64 payloads in id order.
+     */
+    serializeDraftImages(imageIds: readonly DraftAttachmentId[]): Promise<readonly SubmitImageAttachment[]>;
+    /**
+     * Release one browser-owned draft image and preview URL.
+     * @param id - draft attachment id.
+     */
+    releaseDraftImage(id: DraftAttachmentId): void;
+    /**
+     * Release one browser-selected text attachment.
+     * @param id - draft attachment id.
+     */
+    releaseDraftBrowserAnnotation(id: DraftAttachmentId): void;
+    /**
+     * Release a set of browser-owned draft images.
+     * @param attachments - descriptors to release.
+     */
+    releaseDraftImages(attachments: readonly ComposerAttachment[]): void;
+    /**
+     * Release a set of browser-selected text attachments.
+     * @param attachments - descriptors to release.
+     */
+    releaseDraftBrowserAnnotations(attachments: readonly DraftBrowserAnnotation[]): void;
+    /**
+     * Resolve and cache one session-authorized image or video URL.
+     * @param sessionId - owning session authorization scope.
+     * @param attachment - durable media reference.
+     * @returns browser URL valid until its rendered session is released.
+     */
+    resolveMedia(sessionId: SessionId, attachment: ImageAttachmentRef | VideoAttachmentRef): Promise<string>;
+    /**
+     * Release every historical image URL owned by one rendered session.
+     * @param sessionId - rendered session scope.
+     */
+    releaseSessionImages(sessionId: SessionId): void;
+    /** Apply one operation to a pending queue occurrence. */
+    updateQueue(itemId: QueueItemId, action: QueueAction): Promise<void>;
+    /** Cancel the scoped session's in-flight turn while preserving Queue (failures land in promptError and reject, as in send). */
+    cancel(): Promise<void>;
+    /** Pull one older history page for the scoped Session. */
+    loadOlder(): Promise<void>;
+    /** Resolve the caller scope's session face or throw on root contexts. */
+    private scopedSession;
+    /** Read the caller's session scope tag via the sessions service; root contexts fail loud. */
+    private scopeId;
+    private requireSessions;
+    /** Convert browser files to canonical base64 prompt parts. */
+    private serializeImages;
+    /** Canonical base64 wire form of one browser image file. */
+    private encodeImage;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@hydraharness/harness-client-ui-slots';
+import type { BusyEnterBehavior } from '../contract/composer-submission.ts';
+/** Registration-side preference face. */
+export interface EnterBehaviorRowInjected {
+    hooks: {
+        /** Persisted busy-state preference bound as useBusyEnter. */
+        busyEnter: SnapshotStore<BusyEnterBehavior>;
+    };
+    /** Change the busy-state plain-Enter behavior. */
+    setBusyEnter: (behavior: BusyEnterBehavior) => void;
+}
+/** Full Settings-row props. */
+export type EnterBehaviorRowProps = PropsRuntime<'settings.general.item'> & PropsLocale<'conversation'> & InjectFace<EnterBehaviorRowInjected>;
+/**
+ * Render the busy-state Enter behavior selector.
+ * @param props - composed Settings slot props.
+ * @returns the preference row.
+ */
+export declare function EnterBehaviorRow({ useBusyEnter, setBusyEnter, t }: EnterBehaviorRowProps): import("react").JSX.Element;
+//# sourceMappingURL=EnterBehaviorRow.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { SessionListState } from '@hydraharness/harness-client-runtime/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@hydraharness/harness-client-ui-slots';
+export interface UsageRow {
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+/** Registration-side face: pull a fresh session.list when the page opens. */
+export interface UsageSectionInjected {
+    /** Refresh the session list so cold rows carry the latest modelTokenUsage cut. */
+    refresh: () => Promise<void>;
+}
+/** Sum each session's durable model buckets without assigning usage to its latest model. */
+export declare function collectModelUsage(list: Pick<SessionListState, 'ids' | 'byId'>): UsageRow[];
+/** Whether two usage tables carry the same provider/model totals in the same order. */
+export declare function usageRowsEqual(left: readonly UsageRow[], right: readonly UsageRow[]): boolean;
+export type UsageSectionProps = PropsRuntime<'settings.section'> & PropsLocale<'conversation'> & InjectFace<UsageSectionInjected>;
+/** Render exact token counts grouped across every listed session. */
+export declare function UsageSection({ useSessions, refresh, t }: UsageSectionProps): import("react").JSX.Element;
+//# sourceMappingURL=UsageSection.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { RunningToolCall } from '@hydraharness/harness-client-runtime/client';
+import { type ApprovalComposerProps } from '../contract/slots.ts';
+/** Extract the shell command from an approval's paired running call (bash-family args carry `command`); undefined hides the line. */
+export declare function commandOf(call: RunningToolCall | undefined): string | undefined;
+/**
+ * Composer takeover boundary: mints the domain face on the carrier's stable
+ * identity and remounts the flow per request key, so the one-shot answered
+ * latch never leaks to the next pending approval.
+ * @param props - the selector-matched pending approval carrier plus the framework standard kit.
+ * @returns The approval prompt for this request.
+ */
+export declare function ApprovalPanel(props: ApprovalComposerProps): import("react").JSX.Element;
+//# sourceMappingURL=ApprovalPanel.d.ts.map

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

@@ -0,0 +1,14 @@
+/** Composer context-occupancy meter: a ring beside the send button fed by the
+ * `contextPressure` projection, with a click-open panel of the heuristic
+ * `contextBreakdown` composition (system prompt, tools, conversation).
+ * Renders nothing until a provider reports both pressure and a route
+ * capacity. */
+import type { UseProjection } from '@hydraharness/harness-client-runtime/client';
+import type { ComposerBarProps } from '../contract/slots.ts';
+export interface ContextMeterProps {
+    useProjection: UseProjection;
+    /** The owning bar's locale seat, passed down as a plain prop. */
+    t: ComposerBarProps['t'];
+}
+export declare function ContextMeter({ useProjection, t }: ContextMeterProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ContextMeter.d.ts.map

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

@@ -0,0 +1,5 @@
+import type { ConversationSlotProps } from '../contract/slots.ts';
+/** Full props composed from the slot contract. */
+export type ConversationRootProps = ConversationSlotProps;
+export declare function ConversationRoot({ sessionId, useSession, useSessions, useWorkspaces, useInput, useComposerBlock, renderSlot, renderSlotChain, selectWorkspace, secondary, t, }: ConversationRootProps): import("react").JSX.Element;
+//# sourceMappingURL=ConversationRoot.d.ts.map

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

@@ -0,0 +1,20 @@
+/** Strict per-session header/body content inserted into the resident conversation layout. */
+import type { ConversationSessionHeaderSlotProps, ConversationSessionSlotProps } from '../contract/slots.ts';
+/** Full props composed from the strict session body contract. */
+export type ConversationSessionProps = ConversationSessionSlotProps;
+/** Full props composed from the strict session header contract. */
+export type ConversationSessionHeaderProps = ConversationSessionHeaderSlotProps;
+/**
+ * Renders Session header chrome above the resident conversation scrollport.
+ * @param props - Strict Session store, view ledger, navigation, render, and locale shares.
+ * @returns the hidden blank-session header or visible title and tabs.
+ */
+export declare function ConversationSessionHeader({ sessionId, useSession, useSessions, useStore, actions, renderSlot, views, open, openVersion, referenceVersion, t, }: ConversationSessionHeaderProps): import("react").JSX.Element;
+/**
+ * Renders the active Session view inside the resident scrollport and keeps
+ * the input draft mirrored while blank Hero chrome is visible.
+ * @param props - Strict Session input/store, view ledger, and render shares.
+ * @returns the active view area, or null while the Session remains blank.
+ */
+export declare function ConversationSession({ sessionId, useSession, useInput, inputActions, useStore, actions, renderSlot, views, bindDraftMirror, releaseSessionImages, }: ConversationSessionProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ConversationSession.d.ts.map

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

@@ -0,0 +1,5 @@
+import type { DetailsSlotProps } from '../contract/slots.ts';
+/** Full props composed by reference from the contract (automatic shares & injected share). */
+export type DetailsPanelProps = DetailsSlotProps;
+export declare function DetailsPanel({ useSession, useSessions, sessionId, useStore, renderSlot, closeDetails, t }: DetailsPanelProps): import("react").JSX.Element;
+//# sourceMappingURL=DetailsPanel.d.ts.map

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

@@ -0,0 +1,58 @@
+import type { ReactNode, RefObject } from 'react';
+import type { ConversationSlotProps } from '../contract/slots.ts';
+/** The owner's locale seat type, passed to hero chrome as a plain prop. */
+type HeroTranslate = ConversationSlotProps['t'];
+/**
+ * Basename label for the workspace chip (the shared derivation);
+ * separator-only paths echo the raw cwd.
+ * @param cwd - workspace directory path (non-empty).
+ * @returns chip label.
+ */
+export declare function workspaceLabel(cwd: string): string;
+/**
+ * The workspace chip (folder + label + chevron), always interactive: before
+ * the first message the workspace stays switchable — picking another one
+ * moves the New Session flow to that workspace's blank session. Without a
+ * label the chip renders its placeholder state: closed folder + the
+ * "Choose workspace" call to action.
+ * @param props.label - chip label (see {@link workspaceLabel}); omitted → placeholder.
+ * @param props.menuOpen - menu expansion echo.
+ * @param props.onClick - menu toggle.
+ * @returns the chip button element.
+ */
+export declare function WorkspaceChip({ buttonRef, label, menuOpen, disabled, onClick, t }: {
+    buttonRef?: RefObject<HTMLButtonElement>;
+    label?: string | undefined;
+    menuOpen?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+    t: HeroTranslate;
+}): import("react").JSX.Element;
+/**
+ * The soft blue backdrop ellipse (figma 313:14109). Rendered by the hero
+ * owner (ConversationRoot), not HeroShell, so it can center on the input
+ * card; the owner's className supplies all positioning.
+ * @param props.className - positioning class from the owner.
+ * @returns the blurred-ellipse svg element.
+ */
+export declare function HeroGlow({ className }: {
+    className?: string | undefined;
+}): import("react").JSX.Element;
+/** Hero chrome props. The workspace row rides the InputBar accessory hole, not here. */
+export interface HeroShellProps {
+    /** The owner's locale seat, passed down as a plain prop. */
+    t: HeroTranslate;
+    /** Authorized renderer for the hero brand-mark slot. */
+    renderSlot: ConversationSlotProps['renderSlot'];
+    /** Overlay content after the stack (modals). */
+    children?: ReactNode;
+}
+/**
+ * Render the hero chrome (headline only; no glow, no composer, no workspace
+ * row — the glow is the owner's {@link HeroGlow}).
+ * @param props - see {@link HeroShellProps}.
+ * @returns the centered hero element tree.
+ */
+export declare function HeroShell({ t, renderSlot, children }: HeroShellProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=EmptyHero.d.ts.map

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

@@ -0,0 +1,11 @@
+/** The default composer body: the 'conversation.composer.bar' slot entry.
+ * Machine state arrives through the standard provide channel
+ * (useInput + inputActions); the keyboard/DOM command face and stop arrive
+ * through this entry's own inject, whose hooks compartment binds
+ * useNotices/useLexicon; layout-phase inputs (variant, placeholder,
+ * region-slot content) ride the owner props. Session facts
+ * (running/removed/promptError) are self-selected via useSession. */
+import type { ComposerBarProps } from '../contract/slots.ts';
+export type InputBarProps = ComposerBarProps;
+export declare function InputBar({ useSession, useInput, inputActions, keyboard, addImages, removeImage, draftImages, draftBrowserAnnotations, removeBrowserAnnotation, updateBrowserAnnotationComment, resolveSubmitMode, toggleCommandMenu, stop, command, t, renderSlot, useNotices, useLexicon, useMenuLauncher, useProjection, sessionId, variant, disabled: inert, blocked, workspacePickerOpen, onRequestWorkspace, placeholder, accessory, overlay, leftItems, rightItems, footer, }: InputBarProps): import("react").JSX.Element;
+//# sourceMappingURL=InputBar.d.ts.map

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

@@ -0,0 +1,11 @@
+import type { PermissionSelect as PermissionSelectValue } from '@hydraharness/harness-permission-presets/client';
+import type { ComposerBarProps } from '../contract/slots.ts';
+export interface PermissionSelectProps {
+    value: PermissionSelectValue | undefined;
+    locked: boolean;
+    command: (line: string) => Promise<boolean>;
+    /** The owning bar's locale seat, passed down as a plain prop. */
+    t: ComposerBarProps['t'];
+}
+export declare function PermissionSelect({ value, locked, command, t }: PermissionSelectProps): import("react").JSX.Element | null;
+//# sourceMappingURL=PermissionSelect.d.ts.map

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

@@ -0,0 +1,28 @@
+import type { Context } from '@hydraharness/cordis';
+import type { PropsLocale, PropsRuntime } from '@hydraharness/harness-client-ui-slots';
+import type { TodoItem } from '@hydraharness/harness-tool-todo/client';
+export interface TodoPanelProps {
+    /** The session's current plan (empty renders nothing) — selected by the dock adapter. */
+    todos: readonly TodoItem[];
+    /** The dock entry's locale seat, passed down as a plain prop. */
+    t: TodoDockProps['t'];
+}
+export declare function TodoPanel({ todos, t }: TodoPanelProps): import("react").JSX.Element | null;
+/** Full props of a dock entry: InputZone owner share + session standard kit + global seat + the locale seat. */
+export type TodoDockProps = PropsRuntime<'conversation.input.dock'> & PropsLocale<'conversation'>;
+/** Dock adapter: reads the host-computed 'todos' projection (whole list; absent or null renders nothing). */
+export declare function TodoDock({ useProjection, t }: TodoDockProps): import("react").JSX.Element;
+/**
+ * The plan strip as a plain registrant plugin (QueueDock posture), following
+ * the input-dock declaration across independent activation and reload.
+ */
+export declare const todoDockEntry: {
+    name: string;
+    inject: string[];
+    /**
+     * Register the plan strip before the goal and queue entries (order 0).
+     * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
+     */
+    apply(ctx: Context): void;
+};
+//# sourceMappingURL=TodoPanel.d.ts.map

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

@@ -0,0 +1,18 @@
+/** Safari-specific textarea layout recovery for the conversation composer. */
+/** Browser identity fields needed to distinguish Safari from other WebKit-based browsers. */
+export interface BrowserIdentity {
+    readonly userAgent: string;
+    readonly vendor: string;
+}
+/**
+ * Detect Safari's `Version/... Safari/...` form while excluding known alternate iOS browser tokens.
+ * @param identity - Browser user-agent and vendor values.
+ * @returns Whether the identity should use the Safari-specific recovery.
+ */
+export declare function isSafariBrowser(identity: BrowserIdentity): boolean;
+/**
+ * Repair Safari's stale native textarea layout and the scrollport auto height it can contaminate.
+ * @param input - Composer textarea whose own scrollable overflow must stay zero.
+ */
+export declare function repairSafariTextareaLayout(input: HTMLTextAreaElement | null): void;
+//# sourceMappingURL=safari.d.ts.map

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

@@ -0,0 +1,22 @@
+/**
+ * Per-session chat store shared by conversation and details registrations.
+ * The plugin creates its handle at apply time so identity follows the fiber.
+ */
+import { type EngineStoreHandle } from '@hydraharness/harness-client-runtime/client';
+import type { CallId, ChatStoreState, SelectionTarget } from './contract/views.ts';
+/** Declared action shape used to give the exported factory a stable return type. */
+type ChatActions = {
+    select: (draft: ChatStoreState, target: SelectionTarget | null) => void;
+    setDraft: (draft: ChatStoreState, text: string) => void;
+    setView: (draft: ChatStoreState, view: string) => void;
+    setInspect: (draft: ChatStoreState, target: {
+        callId: CallId;
+    } | null) => void;
+};
+/**
+ * Declares the per-session chat state and write surface.
+ * @returns the store handle.
+ */
+export declare function createChatStore(): EngineStoreHandle<ChatStoreState, ChatActions>;
+export {};
+//# sourceMappingURL=stores.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+/** Host registration for browser conversation preferences. */
+import type { Context } from '@hydraharness/cordis';
+export { BUSY_ENTER_BEHAVIORS, BUSY_ENTER_FIELD, CONVERSATION_SETTINGS_NAMESPACE, DEFAULT_BUSY_ENTER_BEHAVIOR, type BusyEnterBehavior, type ConversationSettings, } from './submission-settings.ts';
+/**
+ * Register the durable conversation section when a settings provider exists.
+ * @param ctx - Host context whose optional settings service owns the section.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@hydraharness/harness-client-ui-conversation`.
+ * @module @hydraharness/harness-client-ui-conversation/invariant
+ */
+import type { Context } from '@hydraharness/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-ui-conversation-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/submission-settings.d.ts

@@ -0,0 +1,20 @@
+/** Busy-Enter preference stored in the Host user-settings document. */
+import z from '@hydraharness/schemastery';
+/** Settings namespace owned by the conversation plugin. */
+export declare const CONVERSATION_SETTINGS_NAMESPACE = "ui-conversation";
+/** Field carrying the delivery mode for plain Enter while an agent is busy. */
+export declare const BUSY_ENTER_FIELD = "busyEnter";
+/** Busy-Enter behaviors accepted at settings and input boundaries. */
+export declare const BUSY_ENTER_BEHAVIORS: readonly ["queue", "steer"];
+/** Configurable meaning of plain Enter while the addressed agent is busy. */
+export type BusyEnterBehavior = typeof BUSY_ENTER_BEHAVIORS[number];
+/** Default preserves Enter-as-Queue for running conversations. */
+export declare const DEFAULT_BUSY_ENTER_BEHAVIOR: BusyEnterBehavior;
+/** Durable conversation section shared by the Host schema and the browser scope. */
+export interface ConversationSettings {
+    /** Delivery mode for plain Enter while the addressed agent is busy. */
+    busyEnter: BusyEnterBehavior;
+}
+/** Durable conversation schema; also the wire envelope the browser scope validates against. */
+export declare const ConversationSettingsSchema: z<ConversationSettings>;
+//# sourceMappingURL=submission-settings.d.ts.map