@qilin-agent/client-ui-conversation 0.0.0-stage → 3.1.3

package/lib/types/client/input/editor/text-ref.d.ts

@@ -0,0 +1,49 @@
+import type { EditorConfig, LexicalEditor, SerializedTextNode } from 'lexical';
+import { TextNode } from 'lexical';
+/** JSON form of one text-ref node. */
+export type SerializedTextRefNode = SerializedTextNode;
+/** One matched plain-text reference as a styled, fully editable text node. */
+export declare class TextRefNode extends TextNode {
+    /** Lexical node registry type tag. */
+    static getType(): string;
+    /**
+     * Clone with identity (Lexical writable-copy contract).
+     * @param node - node to clone.
+     * @returns a copy carrying the same NodeKey.
+     */
+    static clone(node: TextRefNode): TextRefNode;
+    /**
+     * Rebuild one text-ref from its JSON form.
+     * @param json - serialized node.
+     * @returns a fresh node.
+     */
+    static importJSON(json: SerializedTextRefNode): TextRefNode;
+    /** Serialize to the JSON node form. */
+    exportJSON(): SerializedTextRefNode;
+    /** Style the span the base TextNode mounts. */
+    createDOM(config: EditorConfig): HTMLElement;
+    /** Entity nodes never merge with plain siblings (the transform owns their bounds). */
+    isTextEntity(): true;
+    /** Editing continues inside; the transform re-evaluates match shape per edit. */
+    canInsertTextBefore(): boolean;
+}
+/**
+ * Register the plain-text reference entity transform. The claim decoration
+ * has precedence on the leading-token seat: while a command claim holds, the
+ * claimed token must stay a plain TextNode (transforms register per concrete
+ * node class, so a TextRefNode would never receive the TextNode claim
+ * transform and the warn color would be lost).
+ * @param editor - the shell-owned editor.
+ * @param lexiconOf - live per-trigger name-roll accessor (the controller's aggregated store).
+ * @param activeToken - live claim token accessor; null while unclaimed.
+ * @returns the unregister disposer.
+ */
+export declare function registerTextRefDecoration(editor: LexicalEditor, lexiconOf: () => ReadonlyMap<'/' | '@', readonly string[]>, activeToken: () => string | null): () => void;
+/**
+ * Force a re-scan of the whole document (transforms only visit dirty nodes;
+ * a lexicon roll change dirties nothing on its own). Queued, not discrete —
+ * the caller may sit inside an update listener.
+ * @param editor - the shell-owned editor.
+ */
+export declare function rescanTextRefs(editor: LexicalEditor): void;
+//# sourceMappingURL=text-ref.d.ts.map

package/lib/types/client/input/editor/view-binding.d.ts

@@ -0,0 +1,60 @@
+/** DOM and keymap bindings installed by the InputBar's existing effects. */
+import type { MouseEvent, MutableRefObject, RefObject } from 'react';
+import type { LexicalEditor } from 'lexical';
+import type { ComposerKeyboard } from '../../contract/draft-editor.ts';
+import type { ComposerBarProps } from '../../contract/slots.ts';
+import type { BusyEnterBehavior } from '../../contract/composer-submission.ts';
+interface DraftViewGate {
+    locked: boolean;
+    machineBusy: boolean;
+    canSteerQueue: boolean;
+    running: boolean;
+    steeringAvailable: boolean;
+    busyEnter: BusyEnterBehavior;
+    intakeFiles: (files: readonly File[]) => void;
+    uploadsPending: boolean;
+    showToast: (text: string) => void;
+    t: ComposerBarProps['t'];
+    canAcceptDrop: boolean;
+}
+/**
+ * Reveal the DOM selection within the draft's own scrollport.
+ * @param scrollRef - the InputBar-owned scrollport reference.
+ */
+export declare function revealDraftSelection(scrollRef: RefObject<HTMLDivElement>): void;
+/**
+ * Focus the borrowed editor and reveal its restored selection.
+ * @param editor - the Session-owned editor.
+ * @param revealSelection - reveal the selection after Lexical restores it.
+ */
+export declare function focusDraftEditor(editor: LexicalEditor, revealSelection: () => void): void;
+/**
+ * Forward wheel movement at the draft's edge to its conversation scrollport.
+ * @param scrollRef - the InputBar-owned scrollport reference.
+ * @returns the listener cleanup, or undefined when the element is absent.
+ */
+export declare function installDraftWheel(scrollRef: RefObject<HTMLDivElement>): (() => void) | undefined;
+/**
+ * Bind this view's file dialog through the existing keyboard face.
+ * @param keyboard - the Session-owned composer operations.
+ * @param gate - live intake availability retained by InputBar.
+ * @param fileInputRef - the view's native file input.
+ * @returns the picker unbind disposer.
+ */
+export declare function installDraftFilePicker(keyboard: ComposerKeyboard, gate: MutableRefObject<Pick<DraftViewGate, 'canAcceptDrop'>>, fileInputRef: RefObject<HTMLInputElement>): () => void;
+/**
+ * Bind editor gestures to the view's live guards and Session operations.
+ * @param editor - the borrowed Session-owned editor.
+ * @param keyboard - the existing composer keyboard operations.
+ * @param gate - live view values read by the installed handlers.
+ * @returns the keymap disposer.
+ */
+export declare function installDraftKeymap(editor: LexicalEditor, keyboard: ComposerKeyboard, gate: MutableRefObject<DraftViewGate>): () => void;
+/**
+ * Keep a toolbar press from moving focus away from the draft.
+ * @param event - the toolbar button's mouse event.
+ * @param editor - the borrowed editor, absent in the inert view.
+ */
+export declare function keepDraftFocus(event: MouseEvent<HTMLButtonElement>, editor: LexicalEditor | null): void;
+export {};
+//# sourceMappingURL=view-binding.d.ts.map

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

@@ -0,0 +1,303 @@
+/**
+ * SessionInput shell: owns the per-session Lexical editor (text + chip
+ * truth) and the pure SubmitMachine (phase/claim/attempt), and choreographs
+ * everything between them — projections and InputState publication, the
+ * scoped-event application verbs, the submit transaction plumbing
+ * (adjudicate via the session's InputTriggerController; claim.submit; default
+ * sink), the notice channel, and the draft persistence mirror.
+ * Package-private; the hub alone constructs it and wires the scoped event
+ * listeners onto it.
+ */
+import type { Context } from '@qilin-agent/kylin';
+import type { InboxState } from '@qilin-agent/agent/types';
+import { type ObservableSnapshot, type SnapshotStore } from '@qilin-agent/client-store';
+import type { LexicalEditor } from 'lexical';
+import type { CommandClaim, ConsumeTokenRequest, DraftAttachmentId, InputActions, InputNotice, InputState, InputTriggerController, SessionInput, SubmitAttachment, SubmitOutcome } from '../contract/input.ts';
+import type { ArbitrateKey, ArbitrateOutcome, ComposerKeyboard, ReferenceInsert, TokenSpan } from '../contract/draft-editor.ts';
+import type { InputSubmitMode } from '../contract/composer-submission.ts';
+/** Popup face the shell needs (dismissal only; typed structurally to avoid a value import). */
+export interface PopupDismissFace {
+    dismiss(): void;
+}
+/**
+ * Construction dependencies of one facade. The slash/popup faces are THUNKS: the
+ * shell is created inside the sessions provide materialization (before the
+ * scope record is queryable), where `slash.sessionOf`/`command.popupFor`
+ * cannot resolve yet — resolution defers to first interactive use.
+ */
+export interface SessionInputDeps {
+    /** Session-scope ctx handed to claim.submit transactions. */
+    actx: Context;
+    /** Enter adjudication face resolver; absent/undefined answer = every '/' line falls to the default sink. */
+    inputTriggers?: (() => InputTriggerController | undefined) | undefined;
+    /** PopupSelect shell face resolver (dismissal on submit lock / escape). */
+    popup?: (() => PopupDismissFace | undefined) | undefined;
+    /** Agent Inbox projection; its next-turn list is overlaid onto InputState.queue. */
+    inbox?: ObservableSnapshot<InboxState | undefined> | undefined;
+    /**
+     * Steer every still-pending queued message into the running turn, in FIFO
+     * order (the empty-draft accelerated-Enter gesture); absent = unsupported.
+     */
+    steerQueue?: (() => void) | undefined;
+    /** The plain-message sink (send choreography / materialize fork — the hub owns it). */
+    defaultSink(text: string, attachmentIds: readonly DraftAttachmentId[], mode: InputSubmitMode, signal: AbortSignal): Promise<SubmitOutcome>;
+    /** Command-plane attachment plumbing (the hub owns the conversation face and the copy). */
+    commandAttachments: {
+        /** Resolve ordered draft ids to wire payloads without sending them; rejects when an id no longer resolves. */
+        serialize(ids: readonly DraftAttachmentId[]): Promise<readonly SubmitAttachment[]>;
+        /** Free consumed draft attachments after a successful command submit. */
+        release(ids: readonly DraftAttachmentId[]): void;
+        /** Localized composer notice for a claimed command that does not accept attachments. */
+        unsupportedNotice(token: string): string;
+    };
+}
+/**
+ * The per-session input facade: scoped-event application verbs +
+ * setDraft/submit + the published InputState store, over a shell-owned
+ * Lexical editor.
+ */
+export declare class SessionInputShell implements SessionInput {
+    private readonly deps;
+    /** Published editor projection + submit-plane state + queue overlay (the InputZone currency source). */
+    readonly state: SnapshotStore<InputState>;
+    /** Latest surfaced notice (null after clear); the bar renders errors as banners and information inline. */
+    readonly notices: SnapshotStore<InputNotice | null>;
+    /** The shell-owned editor (text + chip truth); the composer binds its contenteditable to it. */
+    get editor(): LexicalEditor;
+    /** The public provide-channel action face (one stable identity per session). */
+    readonly actions: InputActions;
+    private readonly core;
+    private readonly draftEditor;
+    private get projection();
+    private rev;
+    private readonly unregister;
+    private noticeSeq;
+    private lastMirroredDraft;
+    private attachmentIds;
+    private disposed;
+    /** Draft persistence mirror (Conversation store write; receives the clipboard projection). */
+    private mirrorFn;
+    /** The mounted composer's file-picker opener (scoped pick-files event target). */
+    private filePicker;
+    /** Default sends retained until admission settles or scope disposal releases their attachments. */
+    private readonly detachedDrafts;
+    /** Failed default sends waiting to be restored together in submission order. */
+    private readonly failedDetached;
+    /** Revision of the last automatic failure restoration. */
+    private failedRestoreRev;
+    private restoringFailures;
+    private attachmentFlightSeq;
+    /** Attachment-only sends retained until admission settles or scope disposal releases their attachments. */
+    private readonly attachmentFlights;
+    private readonly unsubscribeInbox;
+    constructor(deps: SessionInputDeps);
+    /** Re-project, run the claim watch, publish, and feed trigger tracking after every editor commit. */
+    private onEditorUpdate;
+    /**
+     * Replace the whole draft (persisted-draft seed and programmatic writes).
+     * Placeholder-sanitized; newlines split paragraphs; the caret lands at the
+     * end. Merged into history so a seed is not an undoable step of its own.
+     * @param text - the full next draft.
+     */
+    setDraft(text: string): void;
+    /** Append ordered attachment ids unless an admission transaction is locked. */
+    addAttachments(ids: readonly DraftAttachmentId[]): boolean;
+    /**
+     * Remove one attachment id from this draft. Busy admission phases refuse, like
+     * {@link addAttachments}: a removal landing while a command submit serializes
+     * would otherwise vanish from the rail yet still ride the in-flight send.
+     */
+    removeAttachment(id: DraftAttachmentId): boolean;
+    /**
+     * Keep only ids that still resolve in the browser attachment registry.
+     * @param available - live registry ids.
+     */
+    pruneAttachments(available: readonly DraftAttachmentId[]): void;
+    /**
+     * Clear the draft as a successful-send commit: the editor empties (no undo
+     * unit) and the undo history is cut, so Ctrl/Cmd-Z cannot resurrect sent
+     * content (the command path gets the same discipline from submit-settled).
+     * @param attachmentIds - admitted attachment ids to remove from this draft.
+     */
+    commitSend(attachmentIds: readonly DraftAttachmentId[]): void;
+    /**
+     * Insert pasted plain text over the current editor selection
+     * (placeholder-sanitized). The paste event's own default is suppressed by
+     * the caller; PASTE_TAG makes the paste its own history boundary, so one
+     * undo never removes both the paste and typing inside the merge window.
+     * @param text - pasted plain text.
+     */
+    paste(text: string): void;
+    /**
+     * Enter adjudication + submit transaction + default sink. Effects fan out
+     * from the machine; this method only feeds the event. Lock entry
+     * (adjudicating/submitting) force-closes the transient layers: the popup
+     * dismisses and the menu tracks frozen.
+     */
+    submit(mode?: InputSubmitMode): void;
+    /**
+     * Keyboard arbitration while the menu is open.
+     * @param key - the intercepted key.
+     * @param composing - IME composition guard state.
+     * @returns the menu's verdict; 'pass' when no pipeline is mounted.
+     */
+    arbitrate(key: ArbitrateKey, composing: boolean): ArbitrateOutcome;
+    /**
+     * Steer every still-pending queued message into the running turn (the
+     * empty-draft accelerated-Enter gesture). Execution belongs to the hub's
+     * queue choreography; absent dep = the gesture falls back to the machine's
+     * empty-draft no-op.
+     */
+    steerQueue(): void;
+    /**
+     * Space adjudication over the controller's hot state.
+     * @returns true = a claim/insert was applied — the caller preventDefaults.
+     */
+    space(): boolean;
+    /** Dismiss the popupSelect shell (any interaction outside the box). */
+    dismissPopup(): void;
+    /**
+     * The live selection as a detect-coordinate span (menu-launcher synthetic
+     * hits replace it on pick); an absent selection answers a collapsed span at
+     * the document end.
+     * @returns the ordered [start, end) span in detect coordinates.
+     */
+    caretSpan(): {
+        start: number;
+        end: number;
+    };
+    /**
+     * Hot plain-text reference lexicon source for the decoration scan:
+     * delegates to the controller's aggregated store. Stable
+     * identity per shell; without a pipeline the snapshot is the empty Map and
+     * subscribers never fire.
+     */
+    readonly lexicon: ObservableSnapshot<ReadonlyMap<'/' | '@', readonly string[]>>;
+    /**
+     * Apply one command claim (scoped begin-command event listener body): the
+     * editor replaces [0, span.end) with the claim token, then the machine
+     * enters claimed.
+     * @param claim - the command claim from the pick path.
+     * @param span - pick-time span snapshot (detect coordinates).
+     * @returns whether the edit applied (phase, span CAS, and leading guard passed).
+     */
+    beginCommand(claim: CommandClaim, span: TokenSpan): boolean;
+    /**
+     * Apply one reference insertion (scoped insert-reference event listener
+     * body): the editor replaces the span with one chip node, followed by a
+     * separating space unless one is already next.
+     * @param ref - the reference insertion from the pick path.
+     * @param span - pick-time span snapshot (detect coordinates).
+     * @returns whether the edit applied.
+     */
+    insertReference(ref: ReferenceInsert, span: TokenSpan): boolean;
+    /**
+     * Consume one command token after business success (scoped consume-token
+     * event listener body). Span guard: revision CAS then splice; bare-token
+     * guard: trimmed-draft equality then clear.
+     * @param guard - exact span or bare-token guard.
+     * @returns whether the token was consumed.
+     */
+    consumeToken(guard: ConsumeTokenRequest['guard']): boolean;
+    /**
+     * Insert plain reference text over the pick-time span (scoped insert-text
+     * event listener body; the plain-text reference path). The editor gains
+     * ordinary characters — no chip node; the chip look is a scan-derived
+     * decoration, never state.
+     * @param text - the plain reference text to splice in (e.g. `/name `).
+     * @param span - pick-time span snapshot (detect coordinates).
+     * @param keepCompleting - contract passenger; completion re-opening is
+     * automatic here (the update listener re-tracks at the settled caret, so an
+     * open token — a directory pick's trailing slash — reopens the menu without
+     * an explicit re-track).
+     * @returns whether the text was applied.
+     */
+    insertText(text: string, span: TokenSpan, keepCompleting?: boolean): boolean;
+    /**
+     * Surface a notice from outside the machine (detached command results).
+     * @param level - severity tier.
+     * @param text - notice body.
+     */
+    notify(level: 'info' | 'error', text: string): void;
+    /**
+     * Return the keyboard to the composer with the caret it last held. Lexical's
+     * own focus restores its stored selection; a bare DOM focus on the
+     * contenteditable would land the caret at the start instead.
+     */
+    focus(): void;
+    /**
+     * Teardown the shell and return every browser-owned attachment still retained by
+     * the draft or an unsettled default send.
+     * @returns attachment ids the scope disposer must release.
+     */
+    dispose(): readonly DraftAttachmentId[];
+    /** Read the live input state (guard derivation reads here). */
+    get snapshot(): InputState;
+    /**
+     * Bind the draft persistence mirror (Conversation store write). Adopt-on-bind: the
+     * store draft may hold a persisted value from a previous mount; the caller
+     * seeds it via setDraft BEFORE binding, and afterwards every editor-adopted
+     * draft mirrors out.
+     * @param write - store draft write.
+     * @returns the unbind disposer.
+     */
+    bindMirror(write: (text: string) => void): () => void;
+    /**
+     * Bind the mounted composer's file action and live intake availability.
+     * @param picker - availability query and native file-dialog opener.
+     * @returns the unbind disposer.
+     */
+    bindFilePicker(picker: Parameters<ComposerKeyboard['bindFilePicker']>[0]): () => void;
+    /**
+     * Read the mounted composer's live file-intake availability.
+     * @returns false when no accepting composer is mounted.
+     */
+    canPickFiles(): boolean;
+    /**
+     * Open the native file dialog when the mounted composer accepts files.
+     * @returns whether the opener was called.
+     */
+    pickFiles(): boolean;
+    /** The claim token the decoration transform styles; null while unclaimed. */
+    private activeClaimToken;
+    /** Dispatch + execute, refreshing the claim decoration when the styled token flips. */
+    private dispatchRun;
+    private run;
+    private execute;
+    /**
+     * Execute the commit-draft effect: clear the committed content (retaining
+     * a pure typed-during-flight suffix when the snapshot allows) and cut the
+     * undo history so sent content cannot resurrect.
+     */
+    private commitDraft;
+    /**
+     * Prompt serialization before the sink: expand each chip occurrence to its
+     * owner's model form via the session controller's codec routing. Owner
+     * missing or serialization failure rejects the detached send and restores
+     * its editor snapshot. Chip-free drafts skip the async detour.
+     */
+    private sinkSerialized;
+    /** Settle one detached default send independently of other sends. */
+    private settleSink;
+    /** Restore one failed detached send without overwriting text entered after a restoration. */
+    private settleDetachedFailure;
+    /** Rebuild all currently failed snapshots in submission order. */
+    private restoreFailedDrafts;
+    /** Return failed-send attachments to the head of the rail; release happens only after success. */
+    private restoreAttachments;
+    /** Enter adjudication: poll the session controller; failure = notice + draft retained (never a silent downgrade). */
+    private adjudicate;
+    /**
+     * The submit transaction: claim.submit against the session scope; ok maps
+     * from the outcome kind. An accepting claim receives the serialized draft
+     * attachments, which are cleared and released only on a success outcome; a
+     * failure (serialize, transport, or handler error) keeps draft and attachments
+     * for correction.
+     */
+    private beginSubmit;
+    /** Late-settlement guard: superseded attempts and disposed facades drop silently. */
+    private dead;
+    private compose;
+    private publish;
+}
+//# sourceMappingURL=facade.d.ts.map

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

@@ -0,0 +1,100 @@
+/**
+ * InputHub: the SessionInputResolver implementation (`ctx.conversation.input`) — one
+ * SessionInputShell per session, created inside the uiSession provide
+ * materialization (the 'input' standard-kit entry IS the
+ * creation trigger) and torn down by the scope disposer (instance-and-scope
+ * share one lifecycle). The hub registers the scoped input-mutation
+ * listeners on each Session context and owns the default-sink choreography: every session is a
+ * real host entity, so the sink is one unconditional prompt path.
+ */
+import type { Context } from '@qilin-agent/kylin';
+import type { SessionBinding } from '@qilin-agent/api-session-controller/client';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+import type { InputTriggerController, SessionInputResolver, SessionInput } from '../contract/input.ts';
+import type { ComposerKeyboard } from '../contract/draft-editor.ts';
+import { SessionInputShell } from './facade.ts';
+/** Session-addressed input facade registry (SessionInputResolver face + composer-layer extras). */
+export declare class InputHub implements SessionInputResolver {
+    private readonly rootCtx;
+    private readonly t;
+    private readonly shells;
+    /**
+     * @param ctx - client root context (services resolved lazily per call — boot order stays free).
+     * @param t - conversation-namespace translate thunk (reads the active locale at call time).
+     */
+    constructor(rootCtx: Context, t: TranslateNS<'conversation'>);
+    /**
+     * Resolve the facade for one session-scope ctx (SessionInputResolver face).
+     * @param actx - session-scope context.
+     * @returns the resident per-session facade.
+     */
+    for(actx: Context): SessionInput;
+    /**
+     * Resident shell for one session binding — the provide-channel entry
+     * (called during scope materialization, BEFORE the scope record is
+     * queryable, hence binding-fed and hence the thunked slash/popup deps).
+     * Wires the scoped event listeners + teardown into the session scope.
+     * @param binding - session assembly handle.
+     * @returns the shell.
+     */
+    shellFor(binding: SessionBinding): SessionInputShell;
+    /**
+     * Resident shell by session id (service-face path; the provide channel has
+     * normally created it already — this covers direct id-addressed access).
+     * @param id - session id.
+     * @returns the shell.
+     */
+    shell(id: SessionId): SessionInputShell;
+    /**
+     * The InputBar-exclusive keyboard command face: the shell
+     * satisfies it structurally; package-internal — handed through the
+     * composer-bar entry's inject, never across a plugin boundary.
+     * @param id - session id.
+     * @returns the shell as the keyboard face.
+     */
+    keyboard(id: SessionId): ComposerKeyboard;
+    /**
+     * Query file intake without creating a Session input.
+     * @param id - target Session.
+     * @returns whether its mounted composer currently accepts files.
+     */
+    canPickFiles(id: SessionId): boolean;
+    /**
+     * Open the target composer's file dialog under its live intake policy.
+     * @param id - target Session.
+     */
+    pickFiles(id: SessionId): void;
+    /**
+     * Resolve the optional slash controller for composer chrome that launches
+     * the shared candidate menu without typing a trigger.
+     * @param id - session id.
+     * @returns the resident controller, or undefined when no trigger provider is installed.
+     */
+    inputTriggers(id: SessionId): InputTriggerController | undefined;
+    /**
+     * Default sink: optimistic clear + prompt. The session is always a real
+     * host entity (materialized when its workspace was picked), so there is
+     * exactly one path; a failed first prompt is an ordinary prompt failure
+     * (banner via promptError, draft restored only while untouched).
+     */
+    private sink;
+    /**
+     * Submit every still-pending queued message through QueueDock Steer, in FIFO
+     * request order — the same operation as the queue dock's per-row button.
+     * An Agent stopping before a command (`session/steer-unavailable`) or a row already
+     * claimed by the agent (`session/queue-item-not-found`) converges silently, while a
+     * genuine failure surfaces as one composer notice. Repeated triggers
+     * (e.g. two rapid empty-draft chords) rely on that `session/queue-item-not-found`
+     * convergence: the snapshot may still list a row the host already steered,
+     * and the duplicate Steer is a silent no-op.
+     * @param session - the addressed host session.
+     * @param shell - the resident shell (notice outlet).
+     */
+    private steerQueue;
+    private controller;
+    private popup;
+    private sessions;
+    private conversation;
+}
+//# sourceMappingURL=hub.d.ts.map

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

@@ -0,0 +1,46 @@
+import type { InputEffect, InputEvent, InputState } from '../contract/input.ts';
+/** The submit-plane slice of the published InputState. */
+export interface SubmitSnapshot {
+    readonly phase: InputState['phase'];
+    readonly claim?: InputState['claim'];
+}
+/** Pure phase, claim, and attempt owner for one Session input. */
+export declare class SubmitMachine {
+    private phase;
+    private claim;
+    private seq;
+    private inflight;
+    /** Ordinary sends detached from the editor, retained for settlement validation and cancellation. */
+    private readonly detached;
+    /** Read-only snapshot of the submit-plane state. */
+    get state(): SubmitSnapshot;
+    /**
+     * Feed one event through the machine.
+     * @param ev - submit-plane event.
+     * @returns effects for the SessionInput shell, in execution order.
+     */
+    dispatch(ev: InputEvent): readonly InputEffect[];
+    /** The complete command name retains its claim with or without the argument separator. */
+    private onDraftChanged;
+    /** The editor applied a claim-token replacement; busy phases refuse another claim. */
+    private onClaim;
+    /** Mint an attempt and controller without assigning its lifecycle owner. */
+    private mintAttempt;
+    /** Mint the frozen command/adjudication attempt. */
+    private beginAttempt;
+    /** Mint an ordinary send that leaves the phase plain. */
+    private beginDetached;
+    /** Default-send effects capture the sink input before the editor commit. */
+    private detachedEffects;
+    private onEnter;
+    private onAdjudicated;
+    private onAdjudicationFailed;
+    /** Claimed command settlement retains the frozen transaction semantics. */
+    private onSubmitSettled;
+    /** Settle one ordinary send independently of current phase and other detached sends. */
+    private onSinkSettled;
+    /** Clear after an accepted attachment-only send; it has no text suffix to retain. */
+    private onSendCommitted;
+    private onRelease;
+}
+//# sourceMappingURL=machine.d.ts.map

package/lib/types/client/input/submission-policy.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Composer submission policy. It owns the live busy-Enter preference and
+ * resolves submission gestures into queue/steer delivery modes; Host and
+ * Agent keep the actual delivery-window authority.
+ */
+import { type SnapshotStore } from '@qilin-agent/client-store';
+import type { ConfigForm } from '@qilin-agent/client-ui-settings/client';
+import type { BusyEnterBehavior, ComposerSubmitGesture, InputSubmitMode } from '../contract/composer-submission.ts';
+import type { ConversationSettings } from '../../conversation-settings.ts';
+export { DEFAULT_BUSY_ENTER_BEHAVIOR } from '../../conversation-settings.ts';
+/**
+ * Resolve one submission gesture against the busy-Enter preference. Plain
+ * Enter and the primary Send button share the `enter` gesture, so the button
+ * delivers exactly what Enter would. Direct `steer` is intentionally
+ * best-effort: AgentLoop turns a closed-window submission into the next waking
+ * Queue item.
+ * @param preferred - the live busy-Enter preference.
+ * @param running - whether the addressed agent currently reports busy.
+ * @param gesture - plain Enter (or the Send button) or the Cmd/Ctrl-accelerated chord.
+ * @param steeringAvailable - whether this session transport supports steering.
+ * @returns Queue outside steer-capable busy state; otherwise the preferred mode or its opposite.
+ */
+export declare function resolveSubmitMode(preferred: BusyEnterBehavior, running: boolean, gesture: ComposerSubmitGesture, steeringAvailable: boolean): InputSubmitMode;
+/**
+ * Busy-Enter preference shared by the composer bar inject face and its
+ * Settings row: one live store the bar's submission gestures and Send label
+ * read, backed by the Host user-settings document when one is composed.
+ */
+export declare class ComposerSubmissionPolicy {
+    /** Reactive preference source for the composer bar and the Settings row. */
+    readonly busyEnter: SnapshotStore<BusyEnterBehavior>;
+    private readonly host;
+    /**
+     * @param host - durable preference scope owned by the providing plugin;
+     * absent compositions stay process-local. The adoption subscription shares
+     * the scope's plugin lifetime — a disposed scope never publishes again, so
+     * the policy needs no release hook.
+     */
+    constructor(host?: ConfigForm<ConversationSettings>);
+    /**
+     * Change the busy-state submission behavior; the live value publishes
+     * before the durable write starts.
+     * @param behavior - Queue or Steer.
+     */
+    setBusyEnter(behavior: BusyEnterBehavior): void;
+    /**
+     * Adopt the scope's accepted durable behavior without writing it back.
+     * @param host - the constructor-narrowed scope driving this adoption.
+     */
+    private adopt;
+}
+//# sourceMappingURL=submission-policy.d.ts.map

package/lib/types/client/layout-policy.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Conversation layout policy. It owns the live transcript content width and
+ * carries the pre-durable browser preference forward, backed by the Host
+ * user-settings document so the width the transcript renders at and the width
+ * the General section shows are one fact.
+ */
+import { type SnapshotStore } from '@qilin-agent/client-store';
+import type { ConfigForm } from '@qilin-agent/client-ui-settings/client';
+import type { ConversationSettings } from '../conversation-settings.ts';
+/**
+ * Content width shared by the resident Conversation shell and its Settings
+ * row: one live store both read, backed by the Host user-settings document
+ * when one is composed. `0` leaves the transcript to the layout's adaptive
+ * clamp; any other value is an explicit width in px.
+ */
+export declare class ConversationLayoutPolicy {
+    /** Reactive width source for the shell and the Settings row. */
+    readonly contentWidth: SnapshotStore<number>;
+    private readonly host;
+    /** Width carried from pre-durable storage, awaiting its first Host view. */
+    private pendingSeed;
+    /**
+     * @param host - durable preference scope owned by the same plugin; absent
+     * compositions stay process-local. The adoption subscription shares the
+     * scope's plugin lifetime, so a disposed scope never publishes again.
+     */
+    constructor(host?: ConfigForm<ConversationSettings>);
+    /**
+     * Change the transcript content width. The live value publishes before the
+     * durable write starts. A drag yields a continuous, column-clamped request,
+     * so the request is rounded and bounded here rather than rejected.
+     * @param px - {@link CONTENT_WIDTH_ADAPTIVE} for the adaptive clamp, or a width in px.
+     */
+    setContentWidth(px: number): void;
+    /**
+     * Adopt the scope's accepted durable width without writing it back, unless
+     * the carried pre-durable preference still awaits its first Host view.
+     * @param host - the constructor-narrowed scope driving this adoption.
+     */
+    private adopt;
+}
+//# sourceMappingURL=layout-policy.d.ts.map