@hachej/boring-ui-kit 0.4.2 → 0.4.4

package/dist/markdown-editor.js

@@ -1,5 +1,8 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { captureMarkdownQuote } from './markdown-quote.js';
+import { captureRichMarkdownQuote, installMarkdownHighlights } from './markdown-highlight-layer.js';
+export { markdownMarkerBackground } from './markdown-highlight-layer.js';
 import { TextDraftControls } from './text-draft-controls.js';
 import { useMarkdownAutosave } from './markdown-autosave.js';
 import { Fragment, useDeferredValue, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
@@ -61,7 +64,7 @@ function useKeyboardInset(active) {
     }, [active]);
     return inset;
 }
-function MarkdownEditorSession({ components, controller, title = 'Document', initialMode = 'rich', placeholder = 'Start writing', className, onMountedTools, header = true, showOutline = header, mode: controlledMode, onModeChange, onRichSafety, resolveImage, formattingToolbar = 'pinned', autosave = true, onAutosaveChange, onSaveResult, activeController: active }) {
+function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActivate, components, controller, title = 'Document', initialMode = 'rich', placeholder = 'Start writing', className, onMountedTools, header = true, showOutline = header, mode: controlledMode, onModeChange, onRichSafety, resolveImage, formattingToolbar = 'pinned', autosave = true, onAutosaveChange, onSaveResult, activeController: active }) {
     const Control = components?.button ?? 'button';
     const Bubble = components?.bubble ?? Fragment;
     const Source = components?.textarea ?? 'textarea';
@@ -150,6 +153,18 @@ function MarkdownEditorSession({ components, controller, title = 'Document', ini
             quote: current.isActive('blockquote'), codeBlock: current.isActive('codeBlock'), link: current.isActive('link'), table: current.isActive('table'),
             href: current.isActive('link') ? String(current.getAttributes('link')['href'] ?? '') : '',
         } : null });
+    useEffect(() => {
+        if (!editor || editor.isDestroyed || mode !== 'rich' || !highlights)
+            return;
+        return installMarkdownHighlights(editor, state.text, highlights, onHighlightActivate);
+    }, [editor, state.text, mode, highlights, onHighlightActivate]);
+    useEffect(() => {
+        if (!editor || editor.isDestroyed || mode !== 'rich' || !onQuoteSelection)
+            return;
+        const selected = () => onQuoteSelection(captureRichMarkdownQuote(editor, controller.getSnapshot().text));
+        editor.on('selectionUpdate', selected);
+        return () => { editor.off('selectionUpdate', selected); };
+    }, [editor, controller, mode, onQuoteSelection]);
     const outline = useEditorState({ editor, selector: ({ editor: current }) => {
             if (!current)
                 return null;
@@ -285,7 +300,7 @@ function MarkdownEditorSession({ components, controller, title = 'Document', ini
                                     }).catch(() => { if (active.current === controller)
                                         setError('The heading could not be selected'); });
                             }, children: heading.text || 'Untitled heading' }) }, heading.position)) }) }), uncertain && _jsxs("div", { role: "alert", className: "boring-markdown-alert", children: ["Save acknowledgement was lost. Keep editing while its outcome is checked.", _jsx(Control, { type: "button", onClick: () => run(controller.actions.reconcile), children: "Check save outcome" }), _jsx(Control, { type: "button", onClick: () => run(controller.actions.abandon), children: "Stop checking and refresh, keeping my draft" })] }), conflict && _jsxs("div", { role: "alert", className: "boring-markdown-alert", children: ["The saved document changed. Your local text has been kept.", _jsx(Control, { type: "button", disabled: pending || uncertain, onClick: () => run(controller.actions.refresh), children: "Check saved version" }), _jsx(Control, { type: "button", disabled: pending || uncertain, onClick: () => run(controller.actions.discardToRemote), children: "Discard local changes and reload" })] }), (outcome?.kind === 'denied' || outcome?.kind === 'unavailable' || outcome?.kind === 'file_too_large') && _jsx("p", { role: "alert", className: "boring-markdown-alert", children: outcome.reason }), error && _jsx("p", { role: "alert", className: "boring-markdown-alert", children: error }), state.proposals.map(proposal => _jsxs("article", { "data-boring": "proposal", className: "boring-markdown-proposal", children: [_jsx("h3", { children: proposal.summary || 'Proposed edit' }), _jsxs("details", { children: [_jsx("summary", { children: "Review text changes" }), _jsx(MarkdownProposalDiff, { components: components, proposal: proposal }), _jsxs("details", { children: [_jsx("summary", { children: "Exact before and after" }), _jsx("h4", { children: "Before" }), _jsx("pre", { children: proposal.before }), _jsx("h4", { children: "After" }), _jsx("pre", { children: proposal.after })] })] }), _jsx(Control, { type: "button", disabled: unavailable || pending || uncertain || proposal.adopted, onClick: () => run(() => controller.actions.accept(proposal.id)), children: proposal.adopted ? 'Adopted' : 'Accept and save' }), _jsx(Control, { type: "button", onClick: () => controller.actions.reject(proposal.id), children: "Dismiss proposal" })] }, proposal.id)), mode === 'source'
-                ? _jsx(Source, { ref: sourceInput, className: "boring-markdown-source", "aria-label": `${title} Markdown source`, value: state.text, readOnly: unavailable, spellCheck: false, onChange: event => controller.actions.edit(event.currentTarget.value) })
+                ? _jsx(Source, { ref: sourceInput, className: "boring-markdown-source", "aria-label": `${title} Markdown source`, value: state.text, readOnly: unavailable, spellCheck: false, onSelect: event => onQuoteSelection?.(captureMarkdownQuote(state.text, { start: event.currentTarget.selectionStart, end: event.currentTarget.selectionEnd })), onChange: event => controller.actions.edit(event.currentTarget.value) })
                 : _jsx("div", { className: "boring-markdown-surface", onKeyDownCapture: markInteraction, onBeforeInputCapture: markInteraction, onInputCapture: markInteraction, onPasteCapture: markInteraction, onDropCapture: markInteraction, onChangeCapture: markInteraction, onClickCapture: event => { markInteraction(); if (event.target instanceof Element && event.target.closest('a'))
                         event.preventDefault(); }, onAuxClickCapture: event => { if (event.target instanceof Element && event.target.closest('a'))
                         event.preventDefault(); }, children: _jsx(EditorContent, { editor: editor }) })] });

package/dist/markdown-highlight-layer.d.ts

@@ -0,0 +1,26 @@
+import type { Editor } from '@tiptap/core';
+import { captureMarkdownQuote, type MarkdownQuoteAnchor, type MarkdownQuoteRange } from './markdown-quote.js';
+import type { MarkColour } from './mark-store.js';
+export interface MarkdownDecoration {
+    readonly id: string;
+    readonly anchor: MarkdownQuoteAnchor;
+    readonly colour: MarkColour;
+    readonly active?: boolean;
+    readonly commented?: boolean;
+    readonly commentLabel?: string;
+    readonly confirmed?: {
+        readonly source: string;
+        readonly range: MarkdownQuoteRange;
+    };
+}
+export type MarkdownQuoteCapture = ReturnType<typeof captureMarkdownQuote>;
+export declare function markdownMarkerBackground(colour: MarkColour): string;
+/** The native serializer proves the complete source unchanged after removing two sentinels.
+ * If syntax/escaping/normalization changes, there is no source projection. */
+export declare function markdownTextProjection(editor: Editor, source: string): readonly {
+    readonly rich: number;
+    readonly source: MarkdownQuoteRange;
+}[];
+export declare function captureRichMarkdownQuote(editor: Editor, source: string): MarkdownQuoteCapture;
+export declare function installMarkdownHighlights(editor: Editor, source: string, marks: readonly MarkdownDecoration[], activate?: (id: string) => void): () => void;
+//# sourceMappingURL=markdown-highlight-layer.d.ts.map

package/dist/markdown-highlight-layer.js

@@ -0,0 +1,107 @@
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+import { Decoration, DecorationSet } from '@tiptap/pm/view';
+import { finishRichMarkdown } from './markdown-safety.js';
+import { captureMarkdownQuote, markdownQuoteResolution } from './markdown-quote.js';
+const key = new PluginKey('boring-markdown-highlights');
+const left = 'BORINGQUOTELEFTBOUNDARY', right = 'BORINGQUOTERIGHTBOUNDARY';
+export function markdownMarkerBackground(colour) {
+    return `color-mix(in oklab,var(--${colour}) 12%,color-mix(in oklab,var(--chart-4,var(--accent)) 24%,var(--background)))`;
+}
+/** The native serializer proves the complete source unchanged after removing two sentinels.
+ * If syntax/escaping/normalization changes, there is no source projection. */
+export function markdownTextProjection(editor, source) {
+    if (!editor.markdown || source.includes(left) || source.includes(right) || finishRichMarkdown(editor.getMarkdown(), source) !== source)
+        return [];
+    const leaves = [];
+    editor.state.doc.descendants((node, position) => { if (node.isText && node.text)
+        leaves.push({ position, text: node.text }); });
+    return leaves.flatMap((leaf, index) => {
+        const json = editor.state.doc.toJSON();
+        let count = 0;
+        const insert = (node) => { if (node.type === 'text') {
+            if (count === index)
+                node.text = left + node.text + right;
+            count++;
+        } node.content?.forEach(insert); };
+        insert(json);
+        const marked = finishRichMarkdown(editor.markdown.serialize(json), source);
+        const start = marked.indexOf(left), end = marked.indexOf(right);
+        if (start < 0 || end < start || marked.indexOf(left, start + left.length) !== -1 || marked.indexOf(right, end + right.length) !== -1)
+            return [];
+        if (marked.slice(0, start) + marked.slice(start + left.length, end) + marked.slice(end + right.length) !== source
+            || marked.slice(start + left.length, end) !== leaf.text)
+            return [];
+        return [{ rich: leaf.position, source: { start, end: end - left.length } }];
+    });
+}
+export function captureRichMarkdownQuote(editor, source) {
+    const selection = editor.state.selection;
+    if (selection.empty)
+        return captureMarkdownQuote(source, { start: 0, end: 0 });
+    const mapped = markdownTextProjection(editor, source).find(p => selection.from >= p.rich && selection.to <= p.rich + p.source.end - p.source.start);
+    return mapped ? captureMarkdownQuote(source, { start: mapped.source.start + selection.from - mapped.rich, end: mapped.source.start + selection.to - mapped.rich })
+        : { kind: 'refused', reason: 'This rich selection has no exact source projection. Select the Markdown source instead.' };
+}
+export function installMarkdownHighlights(editor, source, marks, activate) {
+    const doc = editor.state.doc, projection = markdownTextProjection(editor, source), decorations = [];
+    for (const mark of marks) {
+        if (!['accent', 'primary', 'muted'].includes(mark.colour))
+            continue;
+        const placed = markdownQuoteResolution.resolve(mark.anchor, source, source);
+        const confirmed = mark.confirmed;
+        const range = confirmed?.source === source && placed.kind === 'ambiguous'
+            && placed.candidates.some(candidate => candidate.start === confirmed.range.start && candidate.end === confirmed.range.end)
+            ? confirmed.range : placed.kind === 'exact' || placed.kind === 'moved' ? placed.range : null;
+        if (!range)
+            continue;
+        let indicatorPosition;
+        for (const leaf of projection) {
+            const from = Math.max(leaf.source.start, range.start), to = Math.min(leaf.source.end, range.end);
+            if (from < to) {
+                indicatorPosition = leaf.rich + to - leaf.source.start;
+                decorations.push(Decoration.inline(leaf.rich + from - leaf.source.start, indicatorPosition, { 'data-mark-id': mark.id, 'data-mark-colour': mark.colour, 'data-mark-active': String(mark.active === true), role: 'button', tabindex: '0', 'aria-label': mark.anchor.fallback,
+                    style: `background-color:${markdownMarkerBackground(mark.colour)};color:var(--foreground);${mark.active ? 'outline:var(--border-width, 1px) solid var(--ring);' : ''}` }));
+            }
+        }
+        if (mark.commented && indicatorPosition !== undefined)
+            decorations.push(Decoration.widget(indicatorPosition, () => {
+                const document = editor.view.dom.ownerDocument, indicator = document.createElement('span');
+                indicator.dataset['markComment'] = mark.id;
+                indicator.setAttribute('role', 'img');
+                indicator.setAttribute('aria-label', mark.commentLabel ?? 'Has a comment');
+                indicator.style.cssText = 'display:inline-flex;vertical-align:super;margin-inline-start:0.15em;color:var(--muted-foreground)';
+                const icon = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+                icon.setAttribute('viewBox', '0 0 16 16');
+                icon.setAttribute('width', '0.75em');
+                icon.setAttribute('height', '0.75em');
+                icon.setAttribute('aria-hidden', 'true');
+                const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+                path.setAttribute('d', 'M3 2.5h10v8H7l-4 3v-11Z');
+                path.setAttribute('fill', 'none');
+                path.setAttribute('stroke', 'currentColor');
+                icon.append(path);
+                indicator.append(icon);
+                return indicator;
+            }, { side: -1, key: `comment-${mark.id}` }));
+    }
+    const activateElement = (event) => {
+        const element = event.target;
+        const target = element?.closest?.('[data-mark-id], [data-mark-comment]');
+        const id = target?.getAttribute('data-mark-id') ?? target?.getAttribute('data-mark-comment');
+        if (!id)
+            return false;
+        activate?.(id);
+        return true;
+    };
+    const decorationSet = DecorationSet.create(doc, decorations);
+    editor.registerPlugin(new Plugin({ key, props: {
+            decorations: state => state.doc === doc ? decorationSet : DecorationSet.empty,
+            handleDOMEvents: { click: (_view, event) => activateElement(event), contextmenu: (_view, event) => { if (!activateElement(event))
+                    return false; event.preventDefault(); return true; },
+                keydown: (_view, event) => { if (event.key !== 'Enter' && event.key !== ' ')
+                    return false; if (!activateElement(event))
+                    return false; event.preventDefault(); return true; } },
+        } }));
+    return () => { if (!editor.isDestroyed)
+        editor.unregisterPlugin(key); };
+}

package/dist/markdown-quote.d.ts

@@ -0,0 +1,23 @@
+import type { Anchor, AnchorResolution } from './contracts.js';
+/** Offsets address the canonical Markdown string in UTF-16, never rendered text. */
+export interface MarkdownQuoteRange {
+    readonly start: number;
+    readonly end: number;
+}
+export interface MarkdownQuoteAnchor extends Anchor {
+    readonly kind: 'markdown.quote@1';
+    readonly exact: string;
+    readonly prefix: string;
+    readonly suffix: string;
+    readonly start: number;
+    readonly fallback: string;
+}
+export declare function captureMarkdownQuote(source: string, range: MarkdownQuoteRange): {
+    readonly kind: 'captured';
+    readonly anchor: MarkdownQuoteAnchor;
+} | {
+    readonly kind: 'refused';
+    readonly reason: string;
+};
+export declare const markdownQuoteResolution: AnchorResolution<MarkdownQuoteAnchor, string, MarkdownQuoteRange>;
+//# sourceMappingURL=markdown-quote.d.ts.map

package/dist/markdown-quote.js

@@ -0,0 +1,39 @@
+const boundary = (text, at) => !(at > 0 && at < text.length && /[\uD800-\uDBFF]/.test(text[at - 1]) && /[\uDC00-\uDFFF]/.test(text[at]));
+const offset = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+function parse(value) {
+    if (!value || typeof value !== 'object')
+        throw new TypeError('Expected Markdown quote anchor');
+    const a = value;
+    if (a['kind'] !== 'markdown.quote@1' || typeof a['exact'] !== 'string' || !a['exact'] || typeof a['prefix'] !== 'string'
+        || typeof a['suffix'] !== 'string' || !offset(a['start']) || typeof a['fallback'] !== 'string' || !a['fallback'].trim())
+        throw new TypeError('Invalid Markdown quote anchor');
+    return { kind: 'markdown.quote@1', exact: a['exact'], prefix: a['prefix'], suffix: a['suffix'], start: a['start'], fallback: a['fallback'] };
+}
+export function captureMarkdownQuote(source, range) {
+    if (!offset(range.start) || !offset(range.end) || range.end <= range.start || range.end > source.length || !boundary(source, range.start) || !boundary(source, range.end))
+        return { kind: 'refused', reason: 'Select a nonempty canonical source range' };
+    const exact = source.slice(range.start, range.end);
+    return { kind: 'captured', anchor: { kind: 'markdown.quote@1', exact, prefix: source.slice(Math.max(0, range.start - 32), range.start), suffix: source.slice(range.end, range.end + 32), start: range.start, fallback: exact } };
+}
+export const markdownQuoteResolution = {
+    kind: 'markdown.quote@1',
+    schema: { jsonSchema: { type: 'object', properties: { kind: { const: 'markdown.quote@1' }, exact: { type: 'string', minLength: 1 }, prefix: { type: 'string' }, suffix: { type: 'string' }, start: { type: 'integer', minimum: 0 }, fallback: { type: 'string', minLength: 1 } }, required: ['kind', 'exact', 'prefix', 'suffix', 'start', 'fallback'], additionalProperties: false }, parse },
+    fallback: anchor => anchor.fallback,
+    resolve: (anchor, source, evaluated) => {
+        if (anchor.kind !== 'markdown.quote@1')
+            return { kind: 'unsupported', evaluated };
+        const a = parse(anchor), matches = [];
+        for (let at = source.indexOf(a.exact); at !== -1; at = source.indexOf(a.exact, at + 1)) {
+            if (boundary(source, at) && boundary(source, at + a.exact.length))
+                matches.push({ start: at, end: at + a.exact.length });
+        }
+        if (!matches.length)
+            return { kind: 'missing', evaluated };
+        const contextual = matches.filter(r => source.slice(Math.max(0, r.start - a.prefix.length), r.start) === a.prefix && source.slice(r.end, r.end + a.suffix.length) === a.suffix);
+        const candidates = contextual.length ? contextual : matches;
+        if (candidates.length !== 1)
+            return { kind: 'ambiguous', candidates, evaluated };
+        const range = candidates[0];
+        return { kind: range.start === a.start ? 'exact' : 'moved', range, evaluated };
+    },
+};

package/dist/native-chat.d.ts

@@ -111,6 +111,23 @@ export interface NativeChatSnapshot {
     readonly stop: 'idle' | 'requested' | 'confirmed' | 'unconfirmed';
     readonly disposed: boolean;
 }
+/** Structural presentation seam. Native controllers retain their concrete IDs, methods and recovery return values. */
+export type ChatSnapshot = Omit<NativeChatSnapshot, 'conversationId' | 'send'> & {
+    readonly conversationId: NativeChatSnapshot['conversationId'] | string;
+    readonly send: ChatSendState | {
+        readonly kind: 'idle' | 'submitting' | 'admitted';
+    } | {
+        readonly kind: 'unknown';
+        readonly reason: string;
+        readonly retryable: boolean;
+    };
+};
+export type ChatController = Pick<NativeChatController, 'subscribe' | 'setText' | 'setAttachments' | 'clearHistory' | 'loadEarlier' | 'connect' | 'stop' | 'dispose'> & {
+    readonly getSnapshot: () => ChatSnapshot;
+    readonly send: (whenBusy?: ChatAttempt['whenBusy'], input?: ChatSendInput) => Promise<unknown>;
+    readonly reconcile: () => Promise<unknown>;
+    readonly retrySameRequest: () => Promise<unknown>;
+};
 export interface NativeChatOptions {
     readonly identity: ChatIdentity;
     readonly conversation: ChatConversation;
@@ -120,6 +137,8 @@ export interface NativeChatOptions {
     readonly history?: NativeChatHistorySource | false;
     /** Validate the exact selected draft before any native admission. */
     readonly beforeSubmit?: (draft: ChatDraft) => Promise<string | undefined>;
+    /** Restore a question after a native model/run error with no answer text. Opt-in, local to this controller; never replays work. */
+    readonly restoreOnError?: boolean;
     /** Only a qualified host boundary can prove a thrown submission was not admitted. */
     readonly definitelyNotAdmitted?: (error: unknown) => boolean;
     readonly onListenerError?: (error: unknown) => void;
@@ -128,6 +147,8 @@ export interface NativeChatOptions {
 export declare function createNativeChatController(options: NativeChatOptions): {
     conversation: ChatConversation;
     getSnapshot: () => NativeChatSnapshot;
+    /** Reads the exact native submission with this controller's Context; observing never aborts or owns its execution. */
+    submissionStatus: (submission: Submission) => Promise<SubmissionRecord>;
     subscribe: (listener: () => void) => (() => void);
     setText: (text: string) => void;
     setAttachments: (attachments: readonly ChatAttachment[]) => void;

package/dist/native-chat.js

@@ -1,3 +1,4 @@
+import { awaitWithContext, withCancel } from '@earendil-works/chord/context';
 import { randomUUID } from '@hachej/boring-files/platform';
 function draft(text, attachments, version) {
     if (typeof text !== 'string' || attachments.some(item => typeof item.id !== 'string' || !item.id || typeof item.name !== 'string'
@@ -23,6 +24,8 @@ export function createNativeChatController(options) {
     const listeners = new Set();
     let watch, opening, disposing;
     const publish = (change) => {
+        if (snapshot.disposed)
+            return;
         snapshot = Object.freeze({ ...snapshot, ...change, ...(change.send ? { send: Object.freeze(change.send) } : {}),
             ...(change.connection ? { connection: Object.freeze(change.connection) } : {}),
             ...(change.history ? { history: Object.freeze(change.history) } : {}), ...(change.outbox ? { outbox: Object.freeze(change.outbox) } : {}) });
@@ -57,7 +60,27 @@ export function createNativeChatController(options) {
         historyScan = undefined;
         return emptyHistory();
     };
+    const restoring = new Map();
+    const hasText = (messages) => messages?.some(message => message.role === 'assistant' && Array.isArray(message.content) && message.content.some(part => part?.type === 'text' && typeof part.text === 'string' && part.text.length > 0)) ?? false;
+    const observeText = (view) => {
+        const live = view.docs['pi.live'], run = live?.['run'];
+        if (!run || typeof run !== 'object' || Array.isArray(run))
+            return;
+        const inputs = run['inputs'], taskId = run['taskId'], generation = live?.['generation'];
+        const message = generation && typeof generation === 'object' && !Array.isArray(generation) ? generation['message'] : undefined;
+        const streamed = message && typeof message === 'object' && !Array.isArray(message) && hasText([{ role: 'assistant', content: message['content'] }]);
+        if (!Array.isArray(inputs))
+            return;
+        for (const item of restoring.values())
+            if (inputs.includes(item.submissionId)) {
+                if (typeof taskId === 'number')
+                    item.runTaskId = taskId;
+                if (streamed || view.entries.some(entry => entry.byTaskId === taskId && hasText(entry.model)))
+                    item.textObserved = true;
+            }
+    };
     const acceptView = (view) => {
+        observeText(view);
         const previous = snapshot.view?.entries;
         const appendOnly = !previous || previous.every((entry, index) => view.entries[index]?.id === entry.id);
         publish({ view, ...(!appendOnly ? { history: invalidateHistory() } : {}) });
@@ -68,9 +91,10 @@ export function createNativeChatController(options) {
     const editable = () => { active(); return snapshot.draft; };
     // The composer is emptied when a message is sent, so a confirmation never has to clear it (text typed meanwhile is a new draft).
     const markAdmitted = (attempt, submissionId, record) => {
-        if (!stillPending(attempt))
-            return;
+        if (snapshot.disposed || !stillPending(attempt))
+            return false;
         publish({ send: { kind: 'admitted', attempt, submissionId, ...(record ? { record } : {}) } });
+        return true;
     };
     /** Messages taken from the composer that wait for the current send (`outbox` in the snapshot). */
     const waiting = [];
@@ -87,11 +111,16 @@ export function createNativeChatController(options) {
             item.resolve(undefined);
         if (snapshot.disposed)
             return;
-        const current = snapshot.draft, back = [...drafts, ...left.map(item => item.draft)].map(item => restoreOf.get(item) ?? item);
+        putBack([...drafts, ...left.map(item => item.draft)], { ...change, ...(left.length || snapshot.outbox.length ? { outbox: Object.freeze([]) } : {}) });
+    };
+    function putBack(selected, change = {}) {
+        if (snapshot.disposed)
+            return;
+        const current = snapshot.draft, back = selected.map(item => restoreOf.get(item) ?? item);
         const text = [...back.map(item => item.text), current.text].filter(value => value.trim()).join('\n');
         const attachments = [...back.flatMap(item => item.attachments), ...current.attachments].filter((item, index, all) => all.findIndex(other => other.id === item.id) === index);
-        publish({ ...change, ...(left.length || snapshot.outbox.length ? { outbox: Object.freeze([]) } : {}), ...(back.length ? { draft: draft(text, attachments, current.version + 1) } : {}) });
-    };
+        publish({ ...change, ...(back.length ? { draft: draft(text, attachments, current.version + 1) } : {}) });
+    }
     function definitelyNotAdmitted(error) {
         try {
             return options.definitelyNotAdmitted?.(error) === true;
@@ -100,6 +129,53 @@ export function createNativeChatController(options) {
             return false;
         }
     }
+    function monitor(attempt, submission) {
+        if (!options.restoreOnError || snapshot.disposed || restoring.has(attempt.requestId))
+            return;
+        const waiter = withCancel(context);
+        const item = { submissionId: submission.id, cancel: waiter.cancel, textObserved: false };
+        restoring.set(attempt.requestId, item);
+        if (snapshot.view)
+            observeText(snapshot.view);
+        void (async () => {
+            try {
+                const record = await awaitWithContext(submission.wait(waiter.context), waiter.context);
+                if (snapshot.disposed || record.id !== item.submissionId || record.conversationId !== conversation.id || record.requestId !== attempt.requestId || record.type !== 'input'
+                    || record.status !== 'unanswered' || !['model_error', 'no_model', 'faulted'].includes(record.reason) || record.entry === undefined || item.textObserved)
+                    return;
+                // The native transcript, not watch timing or connection loss, decides whether the failed input received any text.
+                const minEntryId = record.entry, detail = record.detail;
+                const newest = await awaitWithContext(conversation.entries({}, 1, undefined, waiter.context), waiter.context);
+                const maxEntryId = newest.items[0]?.id;
+                if (maxEntryId === undefined || maxEntryId < minEntryId)
+                    return;
+                let cursor, ended = false;
+                do {
+                    const page = await awaitWithContext(conversation.entries({ minEntryId, maxEntryId, order: 'ascending' }, 40, cursor, waiter.context), waiter.context);
+                    if (snapshot.disposed || item.textObserved)
+                        return;
+                    for (const entry of page.items) {
+                        if (hasText(entry.model))
+                            return;
+                        // One run may consume several inputs and retain interrupted attempts. Neither is the final error boundary.
+                        if (entry.model?.some(message => message.role === 'assistant' && message.stopReason === 'error'
+                            && (item.runTaskId !== undefined ? entry.byTaskId === item.runTaskId : typeof detail === 'string' && message.errorMessage === detail))) {
+                            ended = true;
+                            break;
+                        }
+                    }
+                    cursor = page.next;
+                } while (!ended && cursor !== undefined);
+                if (!snapshot.disposed && !item.textObserved)
+                    putBack([attempt.draft]);
+            }
+            catch { /* Missing settlement/history is unknown, never proof of an empty failed answer. */ }
+            finally {
+                restoring.delete(attempt.requestId);
+                waiter.cancel();
+            }
+        })();
+    }
     async function submitAttempt(attempt) {
         publish({ send: { kind: 'submitting', attempt }, ...(!stopping && snapshot.stop !== 'idle' ? { stop: 'idle' } : {}) });
         if (snapshot.disposed)
@@ -109,7 +185,8 @@ export function createNativeChatController(options) {
                 ? [{ type: 'text', text: attempt.draft.text }, ...attempt.draft.attachments.map(item => ({ ...item.content }))]
                 : attempt.draft.text;
             const submission = await conversation.submit({ type: 'input', requestId: attempt.requestId, content, whenBusy: attempt.whenBusy }, context);
-            markAdmitted(attempt, submission.id);
+            if (markAdmitted(attempt, submission.id))
+                monitor(attempt, submission);
             return submission;
         }
         catch (error) {
@@ -151,6 +228,15 @@ export function createNativeChatController(options) {
     const controller = {
         conversation,
         getSnapshot: () => snapshot,
+        /** Reads the exact native submission with this controller's Context; observing never aborts or owns its execution. */
+        submissionStatus: async (submission) => {
+            active();
+            const record = await submission.status(context);
+            active();
+            if (record.id !== submission.id || record.conversationId !== conversation.id)
+                throw new Error('Submission belongs to a different conversation');
+            return record;
+        },
         subscribe: (listener) => { if (snapshot.disposed)
             return () => { }; listeners.add(listener); return () => { listeners.delete(listener); }; },
         setText: (text) => { const current = editable(); publish({ draft: draft(text, current.attachments, current.version + 1) }); },
@@ -316,7 +402,22 @@ export function createNativeChatController(options) {
             if (record) {
                 if (record.conversationId !== conversation.id || record.requestId !== attempt.requestId || record.type !== 'input')
                     throw new Error('Native submission lookup returned a different binding');
-                markAdmitted(attempt, record.id, record);
+                const admitted = markAdmitted(attempt, record.id, record);
+                if (admitted && options.restoreOnError) {
+                    // Reconciliation observes the original request only; no duplicate submission is made to obtain a handle.
+                    monitor(attempt, { id: record.id, wait: async (waiter) => {
+                            for (;;) {
+                                if (waiter.abortSignal?.aborted)
+                                    throw waiter.abortSignal.reason;
+                                const current = await awaitWithContext(conversation.commit(tx => tx.submissionByRequest(conversation.id, attempt.requestId), waiter), waiter);
+                                if (!current || current.id !== record.id)
+                                    throw new Error('Submission binding is unavailable');
+                                if (current.status === 'done' || current.status === 'unanswered')
+                                    return current;
+                                await awaitWithContext(new Promise(resolve => setTimeout(resolve, 250)), waiter);
+                            }
+                        } });
+                }
             }
             return record;
         },
@@ -367,6 +468,9 @@ export function createNativeChatController(options) {
                 return disposing;
             disposing = Promise.resolve().then(async () => { await opening; const owned = watch; watch = undefined; return owned?.stop(); });
             unlink?.();
+            for (const item of restoring.values())
+                item.cancel();
+            restoring.clear();
             publish({ disposed: true, connection: { kind: 'closed' }, history: invalidateHistory() });
             listeners.clear();
             return disposing;

package/dist/remote-chat.js

@@ -1,4 +1,6 @@
+import { awaitWithContext, BACKGROUND_CONTEXT } from '@earendil-works/chord/context';
 import { applyImmutable } from '@earendil-works/chord/delta';
+import { createChatOutbox } from './chat-outbox.js';
 /** A watch request the host answered with an error status. */
 class WatchRefused extends Error {
     status;
@@ -40,17 +42,19 @@ export async function createRemoteChat(options) {
     // The transport in use: `websocket` until its first socket fails to open, then `http` for good.
     let mode = options.transport ?? 'http', current, seq = 0;
     /** Calls sent over a socket and not answered yet, by call ID: sent again unchanged on the next socket. */
-    const outbox = new Map();
+    const outbox = createChatOutbox();
     function exchange(op, init, extra) {
         const http = () => new Request(url(op, extra), init);
         if (mode !== 'websocket')
             return send(http());
         const id = `c${++seq}`;
         const text = JSON.stringify({ kind: 'call', id, op, params: extra, ...(typeof init.body === 'string' ? { body: JSON.parse(init.body) } : {}) });
-        return new Promise((resolve, reject) => { outbox.set(id, { text, http, resolve, reject }); try {
+        const pending = outbox.enqueue(id, { text, http });
+        try {
             current?.send(text);
         }
-        catch { /* sent again on the next socket */ } });
+        catch { /* sent again on the next socket */ }
+        return pending;
     }
     /** Leave the socket for HTTP: calls still waiting for a socket go over HTTP, unchanged (same request ID, so the host deduplicates). */
     function fallBack() {
@@ -58,7 +62,7 @@ export async function createRemoteChat(options) {
         const pending = [...outbox.values()];
         outbox.clear();
         for (const call of pending)
-            send(call.http()).then(call.resolve, call.reject);
+            send(call.input.http()).then(call.resolve, call.reject);
     }
     async function call(op, init = {}, extra = {}) {
         const response = await exchange(op, init, extra);
@@ -135,11 +139,7 @@ export async function createRemoteChat(options) {
                     return;
                 }
                 if (frame.kind === 'reply') {
-                    const pending = outbox.get(frame.id);
-                    if (pending) {
-                        outbox.delete(frame.id);
-                        pending.resolve(new Response(JSON.stringify(frame.body), { status: frame.status, headers: { 'content-type': 'application/json' } }));
-                    }
+                    outbox.resolve(frame.id, new Response(JSON.stringify(frame.body), { status: frame.status, headers: { 'content-type': 'application/json' } }));
                     return;
                 }
                 if (frame.kind === 'event') {
@@ -158,7 +158,7 @@ export async function createRemoteChat(options) {
                     current = socket;
                     // Unanswered calls go again, unchanged: a submit keeps its request ID, so the host runs it once.
                     for (const pending of outbox.values())
-                        socket.send(pending.text);
+                        socket.send(pending.input.text);
                     ready({ first: frame.view, next, cancel });
                     return;
                 }
@@ -442,11 +442,13 @@ export async function createRemoteChat(options) {
                 throw new Error('Submission is unknown to the remote host'); return record; };
             return {
                 id: submissionId, status,
-                wait: async () => { for (;;) {
-                    const record = await status();
+                wait: async (context) => { for (;;) {
+                    if (context.abortSignal?.aborted)
+                        throw context.abortSignal.reason;
+                    const record = await awaitWithContext(status(), context);
                     if (record.status === 'done' || record.status === 'unanswered')
                         return record;
-                    await new Promise(resolve => setTimeout(resolve, pollMs));
+                    await awaitWithContext(new Promise(resolve => setTimeout(resolve, pollMs)), context);
                 } },
                 abort: () => withdraw(submissionId, requestId),
             };
@@ -460,7 +462,7 @@ export async function createRemoteChat(options) {
             ...(query.order === undefined ? {} : { order: query.order }),
             ...(cursor === undefined ? {} : { cursor: JSON.stringify(cursor) }) })).page,
     };
-    const context = Object.freeze({});
+    const context = BACKGROUND_CONTEXT;
     const close = async () => { const first = unclaimed; unclaimed = undefined; await first?.stop(); };
     return { conversation, context, close, link, withdraw: id => withdraw(id), definitelyNotAdmitted: error => error instanceof SubmissionRefused,
         answer: (callId, answer) => post('answer', { callId, answer }), configure: change => post('configure', change) };

package/dist/shared-chat/error.d.ts

@@ -0,0 +1,10 @@
+/** A channel failure's message and retryability come from the host, or from an unconfirmed transport failure. */
+export declare class ChannelRequestError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly refused: boolean;
+    constructor(code: string, message: string, retryable: boolean, options?: {
+        readonly refused?: boolean;
+    });
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/shared-chat/error.js

@@ -0,0 +1,13 @@
+/** A channel failure's message and retryability come from the host, or from an unconfirmed transport failure. */
+export class ChannelRequestError extends Error {
+    code;
+    retryable;
+    refused;
+    constructor(code, message, retryable, options) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = 'ChannelRequestError';
+        this.refused = options?.refused ?? false;
+    }
+}

package/dist/shared-chat/fake.d.ts

@@ -0,0 +1,39 @@
+import type { ChannelEvent, ChannelMessage, ChannelSource, Conversation, Member, SharedChatState } from './source.js';
+export interface FakeChannelSeed {
+    readonly me: Member;
+    readonly members: Member[];
+    readonly conversations: Conversation[];
+    readonly messages: ChannelMessage[];
+}
+/** Fictional in-memory host. The controls exercise exactly the source events a real host delivers. */
+export declare function createFakeChannelSource(seed: FakeChannelSeed): {
+    me: Member;
+    conversations: () => Promise<Conversation[]>;
+    members: (id: string) => Promise<Member[]>;
+    history: (id: string, opts: {
+        before?: string;
+        limit: number;
+    }) => Promise<{
+        before?: string;
+        messages: ChannelMessage[];
+    }>;
+    send: (input: Parameters<ChannelSource["send"]>[0]) => Promise<ChannelMessage>;
+    action: (input: Parameters<ChannelSource["action"]>[0]) => Promise<void>;
+    subscribe: (id: string, event: (event: ChannelEvent) => void, status?: (status: SharedChatState["status"]) => void) => () => void;
+    emit: (event: ChannelEvent) => void;
+    sends: {
+        conversationId: string;
+        text: string;
+        mentions: string[];
+        replyTo?: string;
+        clientId: string;
+        attachments?: File[];
+    }[];
+    actions: {
+        conversationId: string;
+        requestId: string;
+        actionId: string;
+    }[];
+    setStatus: (status: SharedChatState["status"]) => void;
+};
+//# sourceMappingURL=fake.d.ts.map