@crazx/dsh-client-ui-conversation 0.1.5-alpha.1.zw.3

package/lib/types/client/input/editor/keymap.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Composer keymap over the Lexical command layer: menu arbitration
+ * (arrows/escape/enter), space adjudication, the Enter submit gesture, and
+ * paste routing. Registered at CRITICAL priority so it decides before
+ * @lexical/plain-text's own Enter/paste defaults; a handler returning false
+ * falls through to those defaults (Shift+Enter's line break, ordinary
+ * spaces, text paste the bar routes itself).
+ *
+ * IME guard: a composition-closing Enter/Space must not submit or adjudicate.
+ * KeyboardEvent.isComposing covers most engines; Safari delivers the closing
+ * keydown AFTER compositionend, so a root-element composition watch holds the
+ * guard for 10ms more (the old textarea's proven window); keyCode
+ * 229 is the legacy signal engines emit without isComposing.
+ */
+import type { LexicalEditor } from 'lexical';
+import type { ArbitrateKey, ArbitrateOutcome } from '../../contract/input.ts';
+/** The bar-supplied behavior behind each intercepted gesture. */
+export interface ComposerKeymapHandlers {
+    /** Keyboard arbitration while the menu is open ('pass' when no pipeline). */
+    arbitrate(key: ArbitrateKey, composing: boolean): ArbitrateOutcome;
+    /** Space adjudication; true = a claim was applied — the keystroke is consumed. */
+    space(): boolean;
+    /** Dismiss the popupSelect shell (Escape layering: an open overlay closes first). */
+    dismissPopup(): void;
+    /** Whether Enter may submit right now (locked/busy states refuse). */
+    canSubmit(): boolean;
+    /** The Enter gesture after every guard passed; `accelerated` = Ctrl/Cmd held. */
+    submit(accelerated: boolean): void;
+    /** Pasted files (image intake). */
+    intakeFiles(files: readonly File[]): void;
+    /** Pasted plain text (sanitized insertion through the shell). */
+    pasteText(text: string): void;
+}
+/**
+ * Register the composer keymap on one editor.
+ * @param editor - the shell-owned editor.
+ * @param handlers - bar-supplied behavior.
+ * @returns the unregister disposer.
+ */
+export declare function registerComposerKeymap(editor: LexicalEditor, handlers: ComposerKeymapHandlers): () => void;
+//# sourceMappingURL=keymap.d.ts.map

package/lib/types/client/input/editor/projection.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Composer editor projections: one EditorState, three pure text views.
+ * detectText feeds trigger detection and TokenSpan coordinates (every chip
+ * counts as one U+FFFC — the opaque-reference invariant); clipboardText
+ * feeds persistence, the InputState draft, and submit-plane decisions
+ * (chips expand to their clipboard projection); the model form is not a
+ * text view here — submit serializes chip nodes through their owner codec.
+ * All $-functions must run inside `editor.read()` / `editor.update()`.
+ */
+import type { LexicalNode, NodeKey, Point } from 'lexical';
+import type { Occurrence } from '../../contract/input.ts';
+/** The detect-projection stand-in for one chip (object replacement character). */
+export declare const ATOMIC_CHAR = "\uFFFC";
+/** One leaf (or gap) of the composer document in projection coordinates. */
+export interface ComposerSegment {
+    /** text/linebreak carry a node; chip is atomic; gap is the newline between block elements. */
+    readonly kind: 'text' | 'chip' | 'linebreak' | 'gap';
+    /** The backing node; null only for gap. */
+    readonly node: LexicalNode | null;
+    readonly detectStart: number;
+    readonly detectLength: number;
+    readonly clipboardStart: number;
+    readonly clipboardLength: number;
+    /** gap only: the block elements this newline separates. */
+    readonly gapBetween?: {
+        readonly before: NodeKey;
+        readonly after: NodeKey;
+    };
+}
+/** One walk's product: segments plus the indexes point mapping needs. */
+export interface ComposerLayout {
+    readonly segments: readonly ComposerSegment[];
+    readonly detectLength: number;
+    readonly detectText: string;
+    readonly clipboardText: string;
+    /** Leaf node key → its segment (text/chip/linebreak). */
+    readonly byKey: ReadonlyMap<NodeKey, ComposerSegment>;
+    /** Element key → ordered child keys (root and every block element). */
+    readonly children: ReadonlyMap<NodeKey, readonly NodeKey[]>;
+    /** Element key → detect bounds of its content (gaps excluded). */
+    readonly bounds: ReadonlyMap<NodeKey, {
+        readonly start: number;
+        readonly end: number;
+    }>;
+}
+/**
+ * Walk the composer document once, producing every projection segment in
+ * document order. Blocks (paragraphs) contribute a one-newline gap between
+ * one another in both text projections.
+ * @returns the layout for this EditorState.
+ */
+export declare function $composerLayout(): ComposerLayout;
+/**
+ * Fold one clipboard-projection offset to its detect-projection twin.
+ * Offsets inside a chip's clipboard expansion snap to the chip's trailing
+ * edge; callers only pass boundaries that were once a document end (submit
+ * snapshots), which never split a chip.
+ * @param layout - the current walk product.
+ * @param clipboardOffset - offset into the clipboard projection.
+ * @returns the detect offset covering the same document position.
+ */
+export declare function detectOffsetOfClipboardOffset(layout: ComposerLayout, clipboardOffset: number): number;
+/** The published projection product consumed by the shell every update. */
+export interface EditorProjection {
+    /** Trigger/TokenSpan coordinate text (chip = one U+FFFC). */
+    readonly detectText: string;
+    /** Persistence/InputState draft text (chip = clipboardText). */
+    readonly clipboardText: string;
+    /** InputState-compatible occurrence view (clipboardText coordinates). */
+    readonly occurrences: readonly Occurrence[];
+    /** Range selection in detect coordinates (ordered); null while absent or non-range. */
+    readonly selection: {
+        readonly start: number;
+        readonly end: number;
+    } | null;
+    /** Collapsed caret in detect coordinates; null while the selection is absent or ranged. */
+    readonly caret: number | null;
+}
+/**
+ * Fold one selection point to a detect offset.
+ * @param layout - the current walk product.
+ * @param point - selection anchor/focus point.
+ * @returns detect offset, or null when the point references an unknown node.
+ */
+export declare function $detectOffsetOfPoint(layout: ComposerLayout, point: Point): number | null;
+/**
+ * Project the composer document and its caret.
+ * @param idOf - stable occurrence-id assignment per chip NodeKey (the shell
+ * owns the map so ids survive across projections of the same node).
+ * @returns the three-view projection product.
+ */
+export declare function $projectComposer(idOf: (key: NodeKey) => number): EditorProjection;
+//# sourceMappingURL=projection.d.ts.map

package/lib/types/client/input/editor/span-map.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Detect-coordinate span application: the one place that maps a TokenSpan's
+ * numeric [start, end) back onto Lexical points and applies an edit there.
+ * Every slash/input-* event (begin-command, insert-reference, insert-text,
+ * consume-token) lands through here; revision CAS stays with the caller —
+ * this module only maps and edits. All functions
+ * must run inside `editor.update()`.
+ */
+import type { LexicalNode } from 'lexical';
+/** Half-open [start, end) range in detect coordinates (TokenSpan's plane). */
+export interface DetectSpan {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * Select one detect span (collapsed spans place the caret). Exposed for the
+ * shell's caret placement and tests; the replace helpers below build on it.
+ * @param span - detect span to select.
+ * @returns whether both endpoints mapped.
+ */
+export declare function $selectDetectSpan(span: DetectSpan): boolean;
+/**
+ * Replace one detect span with plain text (empty text deletes the span).
+ * The caret lands after the insertion.
+ * @param span - detect span to replace.
+ * @param text - replacement text.
+ * @returns whether the span mapped and the edit applied.
+ */
+export declare function $replaceDetectSpanWithText(span: DetectSpan, text: string): boolean;
+/**
+ * Replace one detect span with nodes (chip insertion path). The caret lands
+ * after the last inserted node.
+ * @param span - detect span to replace.
+ * @param nodes - replacement nodes in order.
+ * @returns whether the span mapped and the edit applied.
+ */
+export declare function $replaceDetectSpanWithNodes(span: DetectSpan, nodes: readonly LexicalNode[]): boolean;
+//# sourceMappingURL=span-map.d.ts.map

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

@@ -0,0 +1,60 @@
+/**
+ * Plain-text reference decoration (the plain-text-reference decision;
+ * see .agents/notes/archived/architecture/2026-07-25-web-input-machine-and-slash-pipeline.md):
+ * a `/name` or `@name` token whose name is on the trigger's lexicon, and
+ * syntax-recognizable `@dir/` folder tokens, render in the chip family
+ * colors. Color only, no icon: a token still carrying its trigger character
+ * is editable text, not a settled chip — the domain icon marks exactly the
+ * settled state. Pure derivation as before — the entity transform converts
+ * matching text into TextRefNode and back as edits move it in and out of
+ * match shape; no occurrence identity exists.
+ */
+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/facade.d.ts

@@ -0,0 +1,298 @@
+/**
+ * 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 '@deepseek-ai/cordis';
+import { type ObservableSnapshot, type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { LexicalEditor } from 'lexical';
+import type { ArbitrateKey, ArbitrateOutcome, CommandClaim, ConsumeTokenRequest, DraftAttachmentId, InputActions, InputNotice, InputState, InputTriggerController, QueuedMessage, ReferenceInsert, SessionInput, SubmitAttachment, SubmitOutcome, TokenSpan } from '../contract/input.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;
+    /** Queue read face; overlaid onto InputState.queue (absent = empty). */
+    queue?: ObservableSnapshot<readonly QueuedMessage[]> | 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. */
+    readonly editor: LexicalEditor;
+    /** The public provide-channel action face (one stable identity per session). */
+    readonly actions: InputActions;
+    private readonly core;
+    private projection;
+    private rev;
+    /** Stable occurrence ids per chip NodeKey (undo restores keys, so ids survive it too). */
+    private readonly occurrenceIds;
+    private occurrenceSeq;
+    private readonly unregister;
+    private noticeSeq;
+    private lastMirroredDraft;
+    private attachmentIds;
+    private disposed;
+    /** Draft persistence mirror (Conversation store write; receives the clipboard projection). */
+    private mirrorFn;
+    /** Live lexicon subscription disposer; undefined until the controller resolves. */
+    private lexiconOff;
+    /** 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;
+    constructor(deps: SessionInputDeps);
+    /**
+     * Run one editor edit whose result is observable on return. At the top
+     * level this is a discrete update. Inside this editor's own update —
+     * command handlers land here synchronously (space/enter picks, paste) —
+     * $-functions are already legal, and wrapping them in update() would DEFER
+     * them past the synchronous bail answer (and a nested discrete throws);
+     * the body runs directly and the outer update commits it.
+     * @param fn - the $-edit body.
+     */
+    private applyEdit;
+    /**
+     * Subscribe the text-ref re-scan to the controller's lexicon once the
+     * controller resolves. The deps thunk cannot resolve at construction (the
+     * shell is created inside the sessions provide materialization), so the
+     * first interactive updates retry until it can.
+     */
+    private ensureLexiconSubscription;
+    /** Re-project, run the claim watch, publish, and feed trigger tracking after every editor commit. */
+    private onEditorUpdate;
+    private occurrenceIdOf;
+    /**
+     * 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;
+    /**
+     * 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;
+    /** 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,88 @@
+/**
+ * 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 '@deepseek-ai/cordis';
+import type { SessionBinding } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-locale/client';
+import type { ComposerKeyboard, InputTriggerController, SessionInputResolver, SessionInput } from '../contract/input.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;
+    /**
+     * 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[];
+    /** Claimed integrity watch: a draft that breaks the token prefix releases the claim. */
+    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