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

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

@@ -0,0 +1,39 @@
+/** Shared conversation view, selection, and store-state contracts. */
+/** Tool call identity as carried on the wire (branded upstream in connection). */
+export type CallId = string;
+/** Selection target for the details linkage channel (toolcall is the step special case). */
+export interface SelectionTarget {
+    turnSeq: number;
+    stepSeq?: number;
+    callId?: CallId;
+    toolName?: string;
+}
+/**
+ * One conversation view tab, projected from a 'conversation.view' slot
+ * entry's registration options (label falls back to the entry id).
+ */
+export interface ViewTab {
+    id: string;
+    label: string;
+}
+/**
+ * Per-session state shared by conversation, chat-view, and details slots.
+ * Unknown persisted view ids fall back to the stable Chat view.
+ */
+export interface ChatStoreState {
+    /** Details-linkage channel (conversation writes, details reads). */
+    selection: SelectionTarget | null;
+    /** Composer draft (persisted; survives session switches and reloads). */
+    draft: string;
+    /** Active conversation view id ('conversation.view' entry id); null falls back to Chat. */
+    view: string | null;
+    /**
+     * One-shot inspect handoff: chat writes the call to reveal, the trajectory
+     * view consumes it and acknowledges by clearing. Read with `?? null` —
+     * persisted snapshots from before this field rehydrate without it.
+     */
+    inspect: {
+        callId: CallId;
+    } | null;
+}
+//# sourceMappingURL=views.d.ts.map

package/lib/types/client/conversation-nodes/assistant.d.ts

@@ -0,0 +1,35 @@
+import type { Context } from '@hydraharness/cordis';
+import type { AssistantBlock, ConversationMatch, ConversationNodeDefinition } from '@hydraharness/harness-client-runtime/client';
+import type { AssistantChatData } from '../contract/chat-nodes.ts';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Streaming, settled, or interrupted Assistant step. */
+        'assistant-step': AssistantChatData;
+    }
+}
+declare module '@hydraharness/harness-client-runtime/client' {
+    interface ConversationStepDataMap {
+        /** Streaming, settled, or interrupted Assistant material for this Step. */
+        'assistant-step': AssistantChatData;
+    }
+}
+interface AssistantState {
+    readonly turn: number;
+    readonly step: number;
+    readonly blocks: readonly (AssistantBlock | undefined)[];
+    readonly firstVisibleSeq: number | undefined;
+    readonly firstVisibleTime: number | undefined;
+    readonly firstTokenTime: number | undefined;
+    readonly hidden: boolean;
+    readonly final: ConversationMatch | undefined;
+    readonly usage: unknown;
+}
+/** Per-step Assistant streaming/final/interruption Definition. */
+export declare const assistantDefinition: ConversationNodeDefinition<AssistantState>;
+/**
+ * Register the Assistant lifecycle business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerAssistantConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=assistant.d.ts.map

package/lib/types/client/conversation-nodes/chat-snapshot-builder.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ChatConversationViewNode, ChatSnapshot, ConversationTimelineSnapshot, ConversationViewBuilder, ConversationViewDefinition } from '@hydraharness/harness-client-runtime/client';
+/** Incremental keyed Chat builder registered under the `chat` target. */
+export declare class ChatSnapshotBuilder implements ConversationViewBuilder<ChatConversationViewNode, ChatSnapshot> {
+    private readonly store;
+    private readonly locations;
+    private readonly legacy;
+    private readonly referenceLabels;
+    private order;
+    readonly empty: ChatSnapshot;
+    constructor();
+    replace(input: {
+        readonly nodes: readonly ChatConversationViewNode[];
+        readonly timeline: ConversationTimelineSnapshot;
+    }): ChatSnapshot;
+    apply(input: {
+        readonly upserts: readonly ChatConversationViewNode[];
+        readonly timeline: ConversationTimelineSnapshot;
+    }): ChatSnapshot;
+    private snapshot;
+}
+/** Chat target factory contributed to the Runtime view registry. */
+export declare const chatViewDefinition: ConversationViewDefinition<ChatConversationViewNode, ChatSnapshot>;
+/**
+ * Register the incremental Chat target builder.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerChatConversationView(ctx: Context): void;
+//# sourceMappingURL=chat-snapshot-builder.d.ts.map

package/lib/types/client/conversation-nodes/command.d.ts

@@ -0,0 +1,54 @@
+import type { Context } from '@hydraharness/cordis';
+import type { CommandNode, CompactionSummaryNode, ConversationMatch, ConversationNodeDefinition } from '@hydraharness/harness-client-runtime/client';
+import type { ManualCompactionChatData } from '../contract/chat-nodes.ts';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Ordinary slash-command lifecycle. */
+        command: CommandNode;
+        /** Manual compact command combined with its compaction transaction. */
+        'manual-compaction': ManualCompactionChatData;
+    }
+}
+type CommandId = CommandNode['commandId'];
+interface CommandState {
+    readonly command: CommandNode;
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+interface CompactionEvidence {
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+/**
+ * Read correlation identity from a compaction replacement checkpoint.
+ * @param event - candidate Session event.
+ * @returns correlated compaction and optional command identity.
+ */
+declare function compactSource(event: Parameters<ConversationNodeDefinition['match']>[0]): {
+    compactionId: string;
+    sourceCommandId?: CommandId;
+} | undefined;
+/**
+ * Build the visible summary marker from optional lifecycle evidence.
+ * @param match - compaction/summary Match, when loaded.
+ * @param checkpoint - replacement checkpoint Match.
+ * @returns final compaction summary Node data.
+ */
+declare function compactSummary(match: ConversationMatch | undefined, checkpoint: ConversationMatch): CompactionSummaryNode;
+/**
+ * Fold shared compaction evidence into a Definition-owned State.
+ * @param state - current business State carrying optional compaction evidence.
+ * @param match - next compaction lifecycle Match.
+ * @returns adopted State, preserving reference identity when the Match adds no evidence.
+ */
+export declare function updateCompactionState<State extends CompactionEvidence>(state: State, match: ConversationMatch): State;
+/** Slash-command lifecycle, including integrated manual compaction, Definition. */
+export declare const commandDefinition: ConversationNodeDefinition<CommandState>;
+/**
+ * Register the command lifecycle business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerCommandConversationNode(ctx: Context): void;
+/** Shared structural checkpoint recognizer for automatic compaction. */
+export { compactSource, compactSummary };
+//# sourceMappingURL=command.d.ts.map

package/lib/types/client/conversation-nodes/common.d.ts

@@ -0,0 +1,40 @@
+import type { ConversationLocation, ConversationNodeContext } from '@hydraharness/harness-client-runtime/client';
+import type { ChatNode, ChatNodeDataMap, ChatNodeKind } from '../contract/chat-nodes.ts';
+/**
+ * Relative positions in one durable event's seq neighborhood: interrupted
+ * Assistant, its follow-up Nodes, then follow-ups to an ordinary final. The
+ * max-tokens notice sits between a closing Assistant and the turn-tail so the
+ * tail stays the turn's last node and keeps its branch action enabled.
+ */
+export declare const CHAT_SYNTHETIC_SEQ_OFFSETS: {
+    readonly interruptedAssistant: -0.9;
+    readonly interruptedFollowup: -0.8;
+    readonly maxTokensNotice: 0.05;
+    readonly finalizedFollowup: 0.1;
+};
+/**
+ * Resolve one Context's best currently loaded event Location.
+ * @param context - assembled business Context.
+ * @returns start or first-match Location, otherwise unresolved.
+ */
+export declare function contextLocation(context: ConversationNodeContext): ConversationLocation;
+/**
+ * Build one final Chat target Node with the engine-owned stable key.
+ * @param context - assembled business Context.
+ * @param kind - Chat renderer dispatch key.
+ * @param anchorSeq - sortable render position.
+ * @param data - renderer-owned payload.
+ * @param options - optional Location and visibility overrides.
+ * @returns final Chat view Node.
+ */
+export declare function chatNode<Kind extends ChatNodeKind>(context: ConversationNodeContext, kind: Kind, anchorSeq: number, data: ChatNodeDataMap[Kind], options?: {
+    readonly location?: ConversationLocation;
+    readonly visibility?: 'visible' | 'hidden';
+}): ChatNode<Kind>;
+/**
+ * Read a finite non-negative integer from a structurally narrowed payload.
+ * @param value - untrusted payload field.
+ * @returns valid coordinate, otherwise undefined.
+ */
+export declare function coordinate(value: unknown): number | undefined;
+//# sourceMappingURL=common.d.ts.map

package/lib/types/client/conversation-nodes/compaction.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@hydraharness/cordis';
+import type { CompactionSummaryNode, ConversationMatch, ConversationNodeDefinition } from '@hydraharness/harness-client-runtime/client';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Automatic compaction checkpoint marker. */
+        compaction: CompactionSummaryNode;
+    }
+}
+interface CompactionState {
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+/** Automatic compaction lifecycle and landed checkpoint Definition. */
+export declare const compactionDefinition: ConversationNodeDefinition<CompactionState>;
+/**
+ * Register the automatic-compaction business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerCompactionConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=compaction.d.ts.map

package/lib/types/client/conversation-nodes/fallback.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationNodeDefinition, UnknownSurfaceNode } from '@hydraharness/harness-client-runtime/client';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Generic presentation of an unclaimed append-surface event. */
+        unknown: UnknownSurfaceNode;
+    }
+}
+/** Unclaimed append-surface fallback Definition. */
+export declare const unknownFallbackDefinition: ConversationNodeDefinition<UnknownSurfaceNode>;
+/**
+ * Register the unmatched append-surface fallback contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerUnknownConversationFallback(ctx: Context): void;
+//# sourceMappingURL=fallback.d.ts.map

package/lib/types/client/conversation-nodes/inbox.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationNodeDefinition } from '@hydraharness/harness-client-runtime/client';
+interface InboxIdentity {
+    readonly id: string;
+}
+/** Cumulative state after one durable inbox splice. */
+export interface InboxState {
+    readonly pending: readonly InboxIdentity[];
+    readonly claimed: ReadonlySet<string>;
+}
+/** Cumulative next-turn inbox splice Definition. */
+export declare const nextTurnInboxDefinition: ConversationNodeDefinition<InboxState>;
+/** Cumulative next-step inbox splice Definition used to classify steering. */
+export declare const nextStepInboxDefinition: ConversationNodeDefinition<InboxState>;
+/**
+ * Register the two durable Inbox-state contributions.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerInboxConversationNodes(ctx: Context): void;
+export {};
+//# sourceMappingURL=inbox.d.ts.map

package/lib/types/client/conversation-nodes/message.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ContextMessageNode, ConversationNodeDefinition, SteeringMessageNode, UserMessageNode } from '@hydraharness/harness-client-runtime/client';
+interface ReferencedUserMessageNode extends UserMessageNode {
+    /** Labels cited by the immediately following session-reference context. */
+    readonly referenceLabels?: readonly string[];
+}
+interface ReferencedSteeringMessageNode extends SteeringMessageNode {
+    /** Labels cited by the immediately following session-reference context. */
+    readonly referenceLabels?: readonly string[];
+}
+type MessageNode = ReferencedUserMessageNode | ReferencedSteeringMessageNode | ContextMessageNode;
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Ordinary turn-opening user message. */
+        user: ReferencedUserMessageNode;
+        /** User message admitted into an active turn. */
+        steering: ReferencedSteeringMessageNode;
+        /** Non-user context injected into model history. */
+        context: ContextMessageNode;
+    }
+}
+/** User, steering, and injected-context message classification Definition. */
+export declare const messageDefinition: ConversationNodeDefinition<MessageNode>;
+/**
+ * Register the user, steering, and injected-context message contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerMessageConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=message.d.ts.map

package/lib/types/client/conversation-nodes/register.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@hydraharness/cordis';
+/**
+ * Register the Chat business Definitions and target builder contributed by this package.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerConversationNodes(ctx: Context): void;
+//# sourceMappingURL=register.d.ts.map

package/lib/types/client/conversation-nodes/retry.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationNodeDefinition, ModelRetryNode } from '@hydraharness/harness-client-runtime/client';
+import type { RetryChatData } from '../contract/chat-nodes.ts';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Producer-correlated model retry chain. */
+        'model-retry': RetryChatData;
+    }
+}
+/** Accumulated retry attempts sharing one producer-owned RetryId. */
+export interface RetryState {
+    readonly turn: number;
+    readonly step: number;
+    readonly attempts: readonly ModelRetryNode[];
+}
+/** Producer-correlated model retry chain Definition. */
+export declare const retryDefinition: ConversationNodeDefinition<RetryState>;
+/**
+ * Register the correlated model-retry business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerRetryConversationNode(ctx: Context): void;
+//# sourceMappingURL=retry.d.ts.map

package/lib/types/client/conversation-nodes/tool.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationNodeDefinition, ToolCallBlock } from '@hydraharness/harness-client-runtime/client';
+import type { ToolChatData } from '../contract/chat-nodes.ts';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Root Tool lifecycle with recursively nested subcalls. */
+        'tool-call': ToolChatData;
+        /** Media generation output rendered outside tool activity groups. */
+        'media-generation': ToolChatData;
+    }
+}
+interface ToolState {
+    readonly root: ToolCallBlock;
+    readonly children: ReadonlyMap<string, readonly ToolCallBlock[]>;
+    readonly parents: ReadonlyMap<string, string>;
+}
+/** Root Tool lifecycle and nested Code Dispatch Definition. */
+export declare const toolDefinition: ConversationNodeDefinition<ToolState>;
+/**
+ * Register the root Tool lifecycle and nested-subcall contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerToolConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=tool.d.ts.map

package/lib/types/client/conversation-nodes/turn-error.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationNodeDefinition, TurnErrorNode } from '@hydraharness/harness-client-runtime/client';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Terminal turn failure recorded on the turn's end reason. */
+        'turn-error': TurnErrorNode;
+    }
+}
+interface TurnErrorState {
+    readonly turn: number;
+    readonly failure?: {
+        readonly seq: number;
+        readonly time: number;
+        readonly message: string;
+        readonly code?: string;
+    };
+}
+/**
+ * Terminal turn failure Definition. Retries run inside the failing turn, so the
+ * turn's `llm/retry` history never suppresses this terminal row; the model-retry
+ * node renders that history separately.
+ */
+export declare const turnErrorDefinition: ConversationNodeDefinition<TurnErrorState>;
+/**
+ * Register the terminal Turn-error business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnErrorConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-error.d.ts.map

package/lib/types/client/conversation-nodes/turn-max-tokens.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationNodeDefinition, TurnMaxTokensNode } from '@hydraharness/harness-client-runtime/client';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Turn ended by the per-request output-token cap. */
+        'turn-max-tokens': TurnMaxTokensNode;
+    }
+}
+interface TurnMaxTokensState {
+    readonly turn: number;
+    readonly seq: number;
+    readonly time: number;
+}
+/** Notice Definition for a turn the provider ended at its output-token cap. */
+export declare const turnMaxTokensDefinition: ConversationNodeDefinition<TurnMaxTokensState>;
+/**
+ * Register the max-tokens turn-end notice contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnMaxTokensConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-max-tokens.d.ts.map

package/lib/types/client/conversation-nodes/turn-tail.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationMatch, ConversationNodeDefinition } from '@hydraharness/harness-client-runtime/client';
+import type { TurnTailChatData } from '../contract/chat-nodes.ts';
+declare module '@hydraharness/harness-client-ui-conversation/client' {
+    interface ChatNodeDataMap {
+        /** Completed-turn actions and extension tail. */
+        'turn-tail': TurnTailChatData;
+    }
+}
+declare module '@hydraharness/harness-client-runtime/client' {
+    interface ConversationTurnDataMap {
+        /** Closing Assistant and footer facts derived for this completed Turn. */
+        'turn-tail': TurnTailChatData;
+    }
+}
+interface TurnTailState {
+    readonly turn: number;
+    readonly end?: ConversationMatch;
+}
+/** Completed-turn footer Definition independent of any Assistant row. */
+export declare const turnTailDefinition: ConversationNodeDefinition<TurnTailState>;
+/**
+ * Register completed-Turn footer data and its Chat node contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnTailConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-tail.d.ts.map

package/lib/types/client/image-labels.d.ts

@@ -0,0 +1,22 @@
+/** Attachment error and limit copy owned by the conversation input flow. */
+import type { ImageAttachmentLimits } from '@hydraharness/harness-attachment';
+import type { Translate } from '@hydraharness/harness-client-ui-slots';
+import type { ConversationKey } from './locales.ts';
+/**
+ * Byte count as user-facing megabytes (`10MB`, `2.5MB`).
+ * @param bytes - the byte count.
+ * @returns the rounded megabyte text.
+ */
+export declare function imageSizeText(bytes: number): string;
+/**
+ * Product copy for a host attachment rejection (the `attachment-error`
+ * `details.reason`). User-solvable reasons name the limit and the way out;
+ * reasons the user cannot act on fold into one send-failed line carrying the
+ * reason code for a bug report.
+ * @param t - the conversation-namespace translate.
+ * @param reason - the wire `details.reason` code.
+ * @param limits - projected limits interpolated into count/size copy, when known.
+ * @returns the banner text.
+ */
+export declare function attachmentErrorText(t: Translate<ConversationKey>, reason: string, limits?: ImageAttachmentLimits): string;
+//# sourceMappingURL=image-labels.d.ts.map

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

@@ -0,0 +1,30 @@
+/**
+ * Browser conversation plugin. `contract/` is the shared type boundary
+ * between the independently implemented skeleton and chat domains; `apply.ts`
+ * owns their slot assembly.
+ */
+export type {} from './conversation-nodes/assistant.ts';
+export type {} from './conversation-nodes/command.ts';
+export type {} from './conversation-nodes/compaction.ts';
+export type {} from './conversation-nodes/fallback.ts';
+export type {} from './conversation-nodes/message.ts';
+export type {} from './conversation-nodes/retry.ts';
+export type {} from './conversation-nodes/tool.ts';
+export type {} from './conversation-nodes/turn-error.ts';
+export type {} from './conversation-nodes/turn-max-tokens.ts';
+export type {} from './conversation-nodes/turn-tail.ts';
+export { apply, inject } from './apply.ts';
+export { ConversationController } from './service.ts';
+export type { BrowserAnnotationSelection, DraftBrowserAnnotation, IConversation } from './service.ts';
+export type { DraftAttachmentId } from './input/contract.ts';
+export type { CallId, ChatStoreState, SelectionTarget, ViewTab, } from './contract/views.ts';
+export type { ConversationKey } from './locales.ts';
+export type { AssistantChatData, ChatNode, ChatNodeDataMap, ChatNodeKind, ManualCompactionChatData, RetryChatData, ToolChatData, TurnTailChatData, } from './contract/chat-nodes.ts';
+export type { ChatFileMentions, ChatNodeOwnerProps, ChatNodeViewProps, ChatStore, ChatViewInjected, ChatViewSlotProps, CommandRowOwnerProps, CommandRowProps, ComposerBarInjected, BrowserAnnotationAttachment, ComposerAttachment, ComposerAttachmentsOwnerProps, ComposerAttachmentsProps, ComposerChainProps, ConversationInjected, ConversationHeaderLineageOwnerProps, ConversationSessionHeaderInjected, ConversationSessionInjected, ConversationSlotProps, ConvViewOwnerProps, ConvViewProps, DetailsInjected, DetailsSlotProps, DetailsToolOwnerProps, EmptyWorkspaceOwnerProps, HeroBrandMarkOwnerProps, MessageImagesOwnerProps, MessageImagesProps, RenderMessageImages, TurnTailOwnerProps, UseChatNodeTurnData, } from './contract/slots.ts';
+declare module '@hydraharness/cordis' {
+    interface Context {
+        /** The outward face only; the concrete service stays inside this plugin. */
+        conversation: import('./service.ts').IConversation;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,57 @@
+/**
+ * Composer blocks: the one way another plugin stops a session's input.
+ *
+ * The composer cannot read the plugins that would know — the dependency runs
+ * ui-model-selection → ui-conversation, never back — so a blocker pushes here and the
+ * bar reads its own session's store. A block carries the localized reason it
+ * exists, because the plugin that raised it owns that copy; the composer only
+ * knows how to render an inert textarea with a placeholder, exactly as it
+ * already does for a session with no workspace.
+ *
+ * This is an affordance, not enforcement: the Host refuses a prompt it cannot
+ * route regardless of what any client disables.
+ */
+import type { SessionId, SnapshotStore } from '@hydraharness/harness-client-runtime/client';
+/** Why one session's composer is inert. */
+export interface ComposerBlock {
+    /**
+     * Localized placeholder replacing the composer's own, owned by the plugin
+     * that raised the block.
+     */
+    readonly reason: string;
+}
+/** The registry face other plugins reach through `ctx.conversation.blocks`. */
+export interface ComposerBlocks {
+    /**
+     * Raise or clear this session's block. Idempotent: setting a block equal to
+     * the current one, or clearing an absent one, notifies nobody.
+     * @param sessionId - the session whose composer is affected.
+     * @param block - the block to raise, or undefined to clear it.
+     */
+    set(sessionId: SessionId, block: ComposerBlock | undefined): void;
+    /**
+     * The store the composer subscribes to for one session. Created on first
+     * read from either side, so a blocker may raise a block before the session's
+     * composer mounts and the composer still sees it.
+     * @param sessionId - the session to observe.
+     * @returns that session's block store (undefined value = not blocked).
+     */
+    storeFor(sessionId: SessionId): SnapshotStore<ComposerBlock | undefined>;
+    /**
+     * Drop one session's store. The session scope's disposer calls this; a
+     * blocker never needs to.
+     * @param sessionId - the session being torn down.
+     */
+    forget(sessionId: SessionId): void;
+}
+/** The per-session composer-block registry (one instance per plugin fiber). */
+export declare class ComposerBlockRegistry implements ComposerBlocks {
+    private readonly stores;
+    /** @inheritdoc */
+    set(sessionId: SessionId, block: ComposerBlock | undefined): void;
+    /** @inheritdoc */
+    storeFor(sessionId: SessionId): SnapshotStore<ComposerBlock | undefined>;
+    /** @inheritdoc */
+    forget(sessionId: SessionId): void;
+}
+//# sourceMappingURL=blocks.d.ts.map