@hachej/boring-ui-kit 0.4.56 → 0.4.57

package/README.md

@@ -50,6 +50,8 @@ Autosave is enabled by default after 1200ms of idle editing and flushes on blur
 
 Use `onAutosaveChange` to register the mounted flush barrier. Await that flush before closing, unmounting or disposing the controller. If it returns false, keep the editor mounted with its refusal/conflict UI unless a real host navigation guard obtains deliberate discard consent. Internal flush registration is not a discard guard. Unmount cleanup and browser page hide are best effort, not substitutes for awaiting the owner teardown barrier. See the [registry recipes](../../registry/README.md) for `MarkdownPane`, viewer-window policy and navigation integration.
 
+A refused save shows Keep mine, Take theirs and Review diff. Keep mine rebases onto the revision the person was shown and saves through the same conditional write; a remote that moved since is a new conflict, never an overwrite. Each save shows its revision. `crossTabRefresh` (default on) tells other tabs of the note to run their existing refresh over BroadcastChannel, carrying only the revision; it is a nudge, not a guarantee, and it does nothing where the browser has no channel. A note over `richSizeLimit` bytes (default 512 KiB) opens in source mode and cannot switch to rich mode.
+
 Proposal review shows added/removed lines with two lines of context and expandable unchanged runs. It preserves exact line endings and marks a missing final newline. An inner details panel retains exact before/after text. Accept and save delegates to the controller; reviewing or expanding context never publishes. Conflict and unknown outcomes expose explicit discard or reconciliation controls.
 
 Detailed alignment uses a matrix of at most 250,000 cells after trimming equal prefix/suffix lines. Larger comparisons show all removed/added middle lines with an explicit notice. This bounds the comparison matrix, not total document size, string-comparison cost or rendered rows.

package/dist/chat-react-conversations.d.ts

@@ -11,8 +11,10 @@ export interface ConversationsClient {
     readonly activeId: string | undefined;
     /** New or fork is on its way: the conversation on screen is about to be left, so it must take no message (`PiChat` disables its composer). */
     readonly creating: boolean;
-    /** The conversation New or fork just opened, for a second: `PiChat` puts the cursor in its box once, and a later remount does not. */
+    /** The conversation New or fork just opened, for up to three seconds: `PiChat` puts the cursor in its box once, then calls `openedSeen`, so a later remount does not. */
     readonly opened: string | undefined;
+    /** Ends `opened` and returns what the person typed since New, for the new box. */
+    readonly openedSeen: () => string;
     readonly reload: () => Promise<void>;
     readonly onSelect: (id: string) => void;
     readonly onNew: () => void;
@@ -34,12 +36,6 @@ export interface ConversationsClientOptions {
     /** How long New or fork may hold the composer (`creating`) before the person gets it back and a late answer no longer moves them. Default 15 s. */
     readonly openTimeoutMs?: number;
 }
-/**
- * The sessions list over the host's conversations handler (`createConversationsHandler` of `@hachej/boring-agent/conversations`, mounted at
- * `endpoint`): the active list (polled every `pollMs` while mounted), server-side search with the Archived filter, New, rename, archive,
- * delete and fork. New and fork select the conversation they made through `onSelect`. `onChange` runs after every change the person made
- * (the host may reload what depends on the list). `fetch` is the host's authenticated fetch. Returns `undefined` until the first list arrives.
- */
 export declare function useConversationsClient({ endpoint, fetch, activeId, onSelect, onChange, pollMs, openTimeoutMs }: ConversationsClientOptions): ConversationsClient | undefined;
 /** Compatibility spelling retained for one release. */
 export declare const useConversations: typeof useConversationsClient;

package/dist/chat-react-conversations.js

@@ -7,10 +7,53 @@ const item = (served) => ({ id: String(served.id), title: served.title ?? undefi
  * delete and fork. New and fork select the conversation they made through `onSelect`. `onChange` runs after every change the person made
  * (the host may reload what depends on the list). `fetch` is the host's authenticated fetch. Returns `undefined` until the first list arrives.
  */
+const OPENED_MS = 3000;
+/**
+ * The clicked button keeps the focus until the new box is back, so a Space typed then would press New again, and the box is held, so the start of a message would be lost.
+ * The focus goes to a hidden field until then: it outlives the chat's remount, and dead keys, IME and Backspace work there. Not on a phone, where it would open the keyboard.
+ */
+function holdTyping() {
+    const page = globalThis.document, focused = page?.activeElement;
+    if (!page || focused?.matches('input, textarea, select, [contenteditable]'))
+        return undefined;
+    const from = focused?.matches('button, [role="button"]') ? focused : undefined;
+    focused?.blur();
+    if (globalThis.matchMedia?.('(pointer: coarse)').matches)
+        return { from, field: undefined };
+    const field = page.createElement('textarea');
+    field.dataset.testid = 'new-chat-typing';
+    field.tabIndex = -1;
+    field.setAttribute('aria-hidden', 'true');
+    field.style.cssText = 'position:fixed;top:0;left:0;width:1px;height:1px;padding:0;border:0;opacity:0;font-size:16px';
+    field.addEventListener('keydown', event => { if (event.key === 'Enter')
+        event.preventDefault(); });
+    page.body.append(field);
+    field.focus();
+    return { from, field };
+}
 export function useConversationsClient({ endpoint, fetch, activeId, onSelect, onChange, pollMs = 4000, openTimeoutMs = 15000 }) {
     const [items, setItems] = useState();
     const [creating, setCreating] = useState(false);
     const [opened, setOpened] = useState();
+    const typing = useRef(undefined);
+    // What was typed goes nowhere else, so nothing reaches the conversation being left. The focus goes back unless the person moved.
+    const dropTyping = useCallback(() => {
+        const held = typing.current;
+        typing.current = undefined;
+        held?.field?.remove();
+        if (globalThis.document?.activeElement === globalThis.document?.body)
+            held?.from?.focus();
+    }, []);
+    useEffect(() => dropTyping, [dropTyping]);
+    const openedTimer = useRef(undefined);
+    const markOpened = useCallback((id) => {
+        clearTimeout(openedTimer.current);
+        if (id !== undefined)
+            openedTimer.current = setTimeout(() => { dropTyping(); setOpened(undefined); }, OPENED_MS);
+        else
+            dropTyping();
+        setOpened(id);
+    }, [dropTyping]);
     // The New or fork on its way; forgetting it gives the composer back, and its late answer then moves nobody.
     const opening = useRef(undefined);
     const forget = useCallback(() => { opening.current = undefined; setCreating(false); }, []);
@@ -43,7 +86,7 @@ export function useConversationsClient({ endpoint, fetch, activeId, onSelect, on
     const reload = useCallback(() => list(), [list]);
     // Another endpoint (another owner's list) starts empty; switching conversations only reloads.
     // eslint-disable-next-line react-hooks/set-state-in-effect -- a new endpoint clears the old owner's list once, after commit
-    useEffect(() => { setItems(undefined); setOpened(undefined); forget(); }, [base, forget]);
+    useEffect(() => { setItems(undefined); markOpened(undefined); forget(); }, [base, forget, markOpened]);
     useEffect(() => {
         if (base === undefined)
             return;
@@ -65,27 +108,48 @@ export function useConversationsClient({ endpoint, fetch, activeId, onSelect, on
             const run = {};
             opening.current = run;
             setCreating(true);
-            const timer = setTimeout(() => { if (opening.current === run)
-                forget(); }, latest.current.openTimeoutMs);
+            const timer = setTimeout(() => { if (opening.current === run) {
+                forget();
+                dropTyping();
+            } }, latest.current.openTimeoutMs);
+            let selected = false;
             try {
                 const { conversationId } = await op(name, body);
                 await changed();
                 if (conversationId !== undefined && opening.current === run) {
-                    setOpened(String(conversationId));
-                    setTimeout(() => setOpened(undefined), 1000);
+                    selected = true;
+                    markOpened(String(conversationId));
                     latest.current.onSelect(String(conversationId));
                 }
             }
             finally {
                 clearTimeout(timer);
-                if (opening.current === run)
+                if (opening.current === run) {
                     forget();
+                    if (!selected)
+                        dropTyping();
+                }
             }
         };
         return {
             items, activeId, creating, opened, reload,
-            onSelect: (id) => { forget(); setOpened(undefined); latest.current.onSelect(id); },
-            onNew: () => { void open('create', {}).catch(() => { }); },
+            openedSeen: () => {
+                const typed = typing.current?.field?.value ?? '';
+                typing.current?.field?.remove();
+                typing.current = undefined;
+                markOpened(undefined);
+                return typed;
+            },
+            onSelect: (id) => { forget(); markOpened(undefined); latest.current.onSelect(id); },
+            onNew: () => {
+                if (!opening.current) {
+                    markOpened(undefined);
+                    typing.current = holdTyping();
+                }
+                else
+                    typing.current?.field?.focus();
+                void open('create', {}).catch(() => { });
+            },
             search: async (query, { archived }, signal) => ((await call({ ...(query ? { q: query } : {}), ...(archived ? { archived: '1' } : {}) }, undefined, signal)).conversations ?? []).map(item),
             rename: async (id, title) => { await op('rename', { conversationId: id, title }); await changed(); },
             archive: async (id, archived) => { await op('archive', { conversationId: id, archived }); await changed(); },
@@ -97,7 +161,7 @@ export function useConversationsClient({ endpoint, fetch, activeId, onSelect, on
                 await open('fork', { conversationId: from, at });
             },
         };
-    }, [items, activeId, creating, opened, call, reload, forget]);
+    }, [items, activeId, creating, opened, call, reload, forget, markOpened, dropTyping]);
 }
 /** Compatibility spelling retained for one release. */
 export const useConversations = useConversationsClient;

package/dist/markdown-conflict-choices.d.ts

@@ -0,0 +1,17 @@
+import type { MarkdownController, MarkdownState } from './markdown.js';
+import type { MarkdownEditorLabels } from './markdown-editor-labels.js';
+import type { SaveResult } from './resources.js';
+import type { ViewerComponents } from './viewer-components.js';
+/** The three ways out of a conflict. Each goes through the controller; nothing here writes or compares revisions itself. */
+export declare function MarkdownConflictChoices({ controller, state, labels, components, disabled, readOnly, setError, run, onSaveResult }: {
+    readonly controller: MarkdownController;
+    readonly state: MarkdownState;
+    readonly labels: MarkdownEditorLabels;
+    readonly components?: ViewerComponents | undefined;
+    readonly disabled: boolean;
+    readonly readOnly: boolean;
+    readonly setError: (message: string | null) => void;
+    readonly run: (operation: () => Promise<unknown>) => void;
+    readonly onSaveResult: (result: SaveResult) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=markdown-conflict-choices.d.ts.map

package/dist/markdown-conflict-choices.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState } from 'react';
+import { MarkdownProposalDiff } from './markdown-proposal-diff.js';
+/** The three ways out of a conflict. Each goes through the controller; nothing here writes or compares revisions itself. */
+export function MarkdownConflictChoices({ controller, state, labels, components, disabled, readOnly, setError, run, onSaveResult }) {
+    const Control = components?.button ?? 'button';
+    const [busy, setBusy] = useState(false);
+    const [review, setReview] = useState(null);
+    const reviewing = useRef(0);
+    const deleted = state.remote?.kind === 'absent';
+    const remoteRevision = state.remote?.kind === 'revision' ? state.remote.target.revision : null;
+    // A diff against a revision that is no longer the known remote would mislead: it closes, and Review diff reads again.
+    const shown = review && (deleted ? review.revision === null : remoteRevision === null || review.revision === remoteRevision) ? review : null;
+    const keepMine = () => {
+        setBusy(true);
+        setError(null);
+        setReview(null);
+        reviewing.current++;
+        void controller.actions.keepLocal().then(result => {
+            // A conflict here always means the remote moved past what the person chose over; a provider's reason would not say so, or say it in their language.
+            if (result.kind === 'conflict')
+                setError(labels.conflictMovedAgain);
+            onSaveResult(result);
+        }, () => setError(labels.operationFailed)).finally(() => setBusy(false));
+    };
+    const toggleReview = () => {
+        const sequence = ++reviewing.current;
+        if (shown) {
+            setReview(null);
+            return;
+        }
+        setBusy(true);
+        setError(null);
+        void controller.actions.readRemote().then(remote => {
+            if (sequence !== reviewing.current)
+                return;
+            if (remote.kind === 'available')
+                setReview({ remote: remote.text, revision: remote.revision });
+            else if (remote.kind === 'missing')
+                setReview({ remote: '', revision: null });
+            else
+                setError(remote.reason);
+        }, () => { if (sequence === reviewing.current)
+            setError(labels.operationFailed); }).finally(() => setBusy(false));
+    };
+    return _jsxs("div", { role: "alert", className: "boring-markdown-alert", "data-boring": "conflict-choices", children: [deleted ? labels.conflictRemoteDeleted : labels.conflictNotice, _jsx(Control, { type: "button", disabled: disabled || busy || readOnly, onClick: keepMine, children: labels.keepMine }), _jsx(Control, { type: "button", disabled: disabled || busy || deleted, onClick: () => run(controller.actions.discardToRemote), children: labels.takeTheirs }), _jsx(Control, { type: "button", disabled: disabled || busy, "aria-expanded": shown !== null, onClick: toggleReview, children: labels.reviewDiff }), shown && _jsxs("div", { style: { flex: '1 1 100%', minWidth: 0 }, children: [_jsx("p", { children: labels.conflictDiffLegend }), _jsx(MarkdownProposalDiff, { components: components, proposal: { before: shown.remote, after: state.text }, name: labels.conflictDiffName, labels: labels })] })] });
+}

package/dist/markdown-editor-labels.d.ts

@@ -1,5 +1,7 @@
 import type { MarkdownEditorMenuLabels } from './viewer-components.js';
 import { type TextDraftLabels } from './text-draft-labels.js';
+/** The reason name `richOff` recognises: unlike the others, this is about the size and not about keeping the text exactly. */
+export declare const MARKDOWN_TOO_LARGE_REASON = "more text than the rich editor can open";
 /**
  * Every word the markdown editor draws itself. `locale` picks the English or French set; `labels` overrides single keys
  * (for example `{ saved: 'Enregistré', sourceName: title => title }`). Text a host supplies (`title`, `placeholder`, a save
@@ -51,7 +53,20 @@ export interface MarkdownEditorLabels extends MarkdownEditorMenuLabels, TextDraf
     readonly checkSaveOutcome: string;
     readonly stopChecking: string;
     readonly conflictNotice: string;
+    readonly keepMine: string;
+    readonly takeTheirs: string;
+    readonly reviewDiff: string;
+    /** Keep mine found a revision the person had not seen yet. */
+    readonly conflictMovedAgain: string;
+    readonly conflictRemoteDeleted: string;
+    /** Accessible name of the Review diff panel. */
+    readonly conflictDiffName: string;
+    readonly conflictDiffLegend: string;
+    /** Short revision shown after a save; the full one is in its `title` and `data-revision`. */
+    readonly savedRevision: (revision: string) => string;
+    /** @deprecated No longer drawn: the conflict strip offers Keep mine, Take theirs and Review diff. Kept so existing overrides still type-check. */
     readonly checkSavedVersion: string;
+    /** @deprecated No longer drawn: see `takeTheirs`. Kept so existing overrides still type-check. */
     readonly discardLocal: string;
     readonly conflictFallback: string;
     readonly saveFallback: string;

package/dist/markdown-editor-labels.js

@@ -1,4 +1,6 @@
 import { textDraftLabels } from './text-draft-labels.js';
+/** The reason name `richOff` recognises: unlike the others, this is about the size and not about keeping the text exactly. */
+export const MARKDOWN_TOO_LARGE_REASON = 'more text than the rich editor can open';
 const frenchBlocks = { 'Front matter': 'Métadonnées', Footnote: 'Note de bas de page', Reference: 'Référence' };
 const frenchReasons = {
     'bare carriage returns': 'des retours chariot isolés',
@@ -25,12 +27,18 @@ export const markdownEditorLabels = {
         uncertainNotice: 'Save acknowledgement was lost. Keep editing while its outcome is checked.',
         checkSaveOutcome: 'Check save outcome', stopChecking: 'Stop checking and refresh, keeping my draft',
         conflictNotice: 'The saved document changed. Your local text has been kept.',
+        keepMine: 'Keep mine', takeTheirs: 'Take theirs', reviewDiff: 'Review diff',
+        conflictMovedAgain: 'The saved document changed again. Nothing was saved.',
+        conflictRemoteDeleted: 'The saved document was deleted. Keep mine creates it again.',
+        conflictDiffName: 'Differences between the saved version and your text',
+        conflictDiffLegend: 'Lines marked − are in the saved version. Lines marked + are in your text.',
+        savedRevision: revision => `Saved revision ${revision}`,
         checkSavedVersion: 'Check saved version', discardLocal: 'Discard local changes and reload',
         conflictFallback: 'The document changed elsewhere. Your text is still available.',
         saveFallback: 'The document could not be saved. Your text is still available.',
         saveFailed: 'The save could not be completed. Your text is still available.',
         operationFailed: 'The operation could not be completed. Your text is still available.',
-        richOff: reasons => `Rich editing is off because this document contains ${reasons.join(', ')}, which it could not keep exactly. You can still edit the Markdown source.`,
+        richOff: reasons => reasons.includes(MARKDOWN_TOO_LARGE_REASON) ? 'Rich editing is off because this document is too large for it. You can still edit the Markdown source.' : `Rich editing is off because this document contains ${reasons.join(', ')}, which it could not keep exactly. You can still edit the Markdown source.`,
         preservedBlockName: kind => kind, frontMatterCode: 'Front matter code',
         proposedLineChanges: 'Proposed line changes', diffFallback: 'Detailed line alignment unavailable; showing changed block.',
         noTextChanges: 'No text changes', crlfLineEnding: 'CRLF line ending', noNewline: 'No newline at end',
@@ -55,12 +63,18 @@ export const markdownEditorLabels = {
         uncertainNotice: 'L’accusé d’enregistrement a été perdu. Continuez à écrire pendant que le résultat est vérifié.',
         checkSaveOutcome: 'Vérifier l’enregistrement', stopChecking: 'Arrêter la vérification et actualiser, en gardant mon brouillon',
         conflictNotice: 'Le document enregistré a changé. Votre texte local a été conservé.',
+        keepMine: 'Garder la mienne', takeTheirs: 'Prendre la leur', reviewDiff: 'Voir les différences',
+        conflictMovedAgain: 'Le document enregistré a encore changé. Rien n’a été enregistré.',
+        conflictRemoteDeleted: 'Le document enregistré a été supprimé. Garder la mienne le recrée.',
+        conflictDiffName: 'Différences entre la version enregistrée et votre texte',
+        conflictDiffLegend: 'Les lignes marquées − sont dans la version enregistrée. Les lignes marquées + sont dans votre texte.',
+        savedRevision: revision => `Révision enregistrée ${revision}`,
         checkSavedVersion: 'Vérifier la version enregistrée', discardLocal: 'Abandonner mes modifications et recharger',
         conflictFallback: 'Le document a été modifié ailleurs. Votre texte est toujours disponible.',
         saveFallback: 'Le document n’a pas pu être enregistré. Votre texte est toujours disponible.',
         saveFailed: 'L’enregistrement n’a pas pu aboutir. Votre texte est toujours disponible.',
         operationFailed: 'L’opération n’a pas pu aboutir. Votre texte est toujours disponible.',
-        richOff: reasons => `La mise en forme est désactivée car ce document contient ${reasons.map(reason => frenchReasons[reason] ?? reason).join(', ')}, qu’elle ne saurait pas conserver à l’identique. Vous pouvez toujours modifier la source Markdown.`,
+        richOff: reasons => reasons.includes(MARKDOWN_TOO_LARGE_REASON) ? 'La mise en forme est désactivée car ce document est trop volumineux. Vous pouvez toujours modifier la source Markdown.' : `La mise en forme est désactivée car ce document contient ${reasons.map(reason => frenchReasons[reason] ?? reason).join(', ')}, qu’elle ne saurait pas conserver à l’identique. Vous pouvez toujours modifier la source Markdown.`,
         preservedBlockName: kind => frenchBlocks[kind] ?? kind,
         frontMatterCode: 'Code des métadonnées', proposedLineChanges: 'Changements de lignes proposés',
         diffFallback: 'Alignement détaillé indisponible ; affichage du bloc modifié.', noTextChanges: 'Aucun changement de texte',

package/dist/markdown-editor.d.ts

@@ -11,7 +11,7 @@ import { type MarkdownImageResolver } from './markdown-extensions.js';
 import { type MarkdownRichSafety } from './markdown-safety.js';
 import { type MarkdownEditorLabelOverrides } from './markdown-editor-labels.js';
 import { type MarkdownMountedTools } from './markdown-mounted.js';
-export { checkMarkdownRichSafety } from './markdown-safety.js';
+export { checkMarkdownRichSafety, MARKDOWN_RICH_SIZE_LIMIT } from './markdown-safety.js';
 export type { MarkdownRichSafety } from './markdown-safety.js';
 export type { MarkdownImageResolver } from './markdown-extensions.js';
 export { markdownEditorLabels } from './markdown-editor-labels.js';
@@ -46,6 +46,10 @@ export interface MarkdownEditorProps {
     /** Registers the async navigation barrier. Null while autosave is disabled or the editor is unmounted. */
     readonly onAutosaveChange?: (flush: MarkdownFlush | null) => void;
     readonly onSaveResult?: (result: SaveResult) => void;
+    /** After a save, tells other tabs of this note in this browser to refresh, when the browser has BroadcastChannel. false keeps tabs apart. */
+    readonly crossTabRefresh?: boolean;
+    /** Above this many UTF-8 bytes the note opens as source and cannot switch to rich mode. Defaults to `MARKDOWN_RICH_SIZE_LIMIT`. */
+    readonly richSizeLimit?: number;
     /** Selection formatting by default. Pinned shows the full row on desktop or above the phone keyboard while editing. */
     readonly formattingToolbar?: 'selection' | 'pinned';
     /** Language of everything the editor draws itself: status, alerts, buttons, accessible names. */

package/dist/markdown-editor.js

@@ -10,14 +10,16 @@ import { createPortal } from 'react-dom';
 import { EditorContent, useEditor, useEditorState } from '@tiptap/react';
 import { BubbleMenu } from '@tiptap/react/menus';
 import { createMarkdownExtensions } from './markdown-extensions.js';
-import { checkMarkdownRichSafety, finishRichMarkdown } from './markdown-safety.js';
+import { checkMarkdownRichSafety, finishRichMarkdown, markdownExceedsRichSize, MARKDOWN_RICH_SIZE_LIMIT } from './markdown-safety.js';
 import { captureMarkdownSource, serializeMarkdownEdit } from './markdown-source.js';
 import { MarkdownIcon } from './markdown-icons.js';
 import { MarkdownProposalDiff } from './markdown-proposal-diff.js';
 import { updatePreservedMarkdownLabels } from './markdown-preserved.js';
 import { resolveMarkdownEditorLabels } from './markdown-editor-labels.js';
 import { createMountedMarkdownTools } from './markdown-mounted.js';
-export { checkMarkdownRichSafety } from './markdown-safety.js';
+import { MarkdownConflictChoices } from './markdown-conflict-choices.js';
+import { useMarkdownTabPoke } from './markdown-tab-poke.js';
+export { checkMarkdownRichSafety, MARKDOWN_RICH_SIZE_LIMIT } from './markdown-safety.js';
 export { markdownEditorLabels } from './markdown-editor-labels.js';
 /** Borrows the controller. The host owns document selection, access and disposal. */
 export function MarkdownEditor(props) {
@@ -77,7 +79,7 @@ function NativeMarkdownViewOptions({ labels, mode, onModeChange, richDisabledRea
         menu.current.open = false; };
     return _jsxs("details", { ref: menu, "data-boring": "markdown-menu", children: [_jsx("summary", { "aria-label": labels.moreActions, children: _jsx(MarkdownIcon, { name: "More" }) }), _jsxs("fieldset", { children: [_jsx("legend", { children: labels.editorMode }), _jsxs("label", { title: richDisabledReason, children: [_jsx(InputControl, { type: "radio", name: group, "aria-label": labels.formatted, "aria-describedby": richDisabledReason ? `${group}-reason` : undefined, checked: mode === 'rich', disabled: !!richDisabledReason, onChange: () => choose(() => onModeChange('rich')) }), _jsx(MarkdownIcon, { name: "Heading1" }), labels.formatted, richDisabledReason && _jsx("span", { id: `${group}-reason`, children: richDisabledReason })] }), _jsxs("label", { children: [_jsx(InputControl, { type: "radio", name: group, "aria-label": labels.markdown, checked: mode === 'source', onChange: () => choose(() => onModeChange('source')) }), _jsx(MarkdownIcon, { name: "Code" }), labels.markdown] })] }), outline && _jsxs("label", { children: [_jsx(InputControl, { type: "checkbox", "aria-label": labels.showOutline, checked: outline.shown, onChange: event => choose(() => outline.onChange(event.currentTarget.checked)) }), _jsx(MarkdownIcon, { name: "BulletList" }), labels.showOutline] })] });
 }
-function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActivate, components, controller, title: titleProp, initialMode = 'rich', placeholder: placeholderProp, className, onMountedTools, header = true, showOutline = header, mode: controlledMode, onModeChange, onRichSafety, resolveImage, formattingToolbar = 'selection', locale = 'en', labels: labelOverrides, autosave = true, onAutosaveChange, onSaveResult, activeController: active }) {
+function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActivate, components, controller, title: titleProp, initialMode = 'rich', placeholder: placeholderProp, className, onMountedTools, header = true, showOutline = header, mode: controlledMode, onModeChange, onRichSafety, resolveImage, formattingToolbar = 'selection', locale = 'en', labels: labelOverrides, autosave = true, onAutosaveChange, onSaveResult, crossTabRefresh = true, richSizeLimit = MARKDOWN_RICH_SIZE_LIMIT, activeController: active }) {
     const text = useMemo(() => resolveMarkdownEditorLabels(locale, labelOverrides), [locale, labelOverrides]);
     const title = titleProp ?? text.defaultTitle;
     const placeholder = placeholderProp ?? text.defaultPlaceholder;
@@ -102,7 +104,12 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
     const checked = useDeferredValue(state.text);
     // The editor's own output is safe by construction; only text that arrived from elsewhere (or from the source box) is checked.
     const ownText = state.text === emitted.current && source.current !== null;
-    const safety = useMemo(() => ownText ? { safe: true } : checkMarkdownRichSafety(checked), [checked, ownText]);
+    const oversized = useMemo(() => markdownExceedsRichSize(state.text, richSizeLimit), [state.text, richSizeLimit]);
+    const safety = useMemo(() => {
+        if (oversized)
+            return checkMarkdownRichSafety(state.text, { maxBytes: richSizeLimit });
+        return ownText ? { safe: true } : checkMarkdownRichSafety(checked, { maxBytes: richSizeLimit });
+    }, [checked, ownText, oversized, richSizeLimit, state.text]);
     const richOffered = safety.safe;
     const mode = richOffered ? requestedMode : 'source';
     const activeMode = useRef(mode);
@@ -149,7 +156,8 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
         setError(null);
     }, [controller]);
     useEffect(() => {
-        if (!editor || editor.isDestroyed || state.text === projected.current)
+        // A note too large for rich mode is never parsed behind the source box; it projects if it comes back under the limit.
+        if (!editor || editor.isDestroyed || oversized || state.text === projected.current)
             return;
         // Text from outside (a load, a refresh, a discard, the source box) starts with the selection at the beginning, where the browser leaves
         // its caret when the text is replaced. Replacing the whole document would otherwise leave the editor's selection at the end while the
@@ -158,7 +166,7 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
         editor.chain().setContent(state.text.replace(/\r\n/g, '\n'), { contentType: 'markdown', emitUpdate: false }).setTextSelection(0).command(({ tr }) => { tr.setMeta('addToHistory', false); return true; }).run();
         source.current = captureMarkdownSource(editor, state.text);
         projected.current = state.text;
-    }, [editor, state.text]);
+    }, [editor, oversized, state.text]);
     useEffect(() => { editor?.setEditable(!state.readOnly && state.lifecycle === 'active'); }, [editor, state.readOnly, state.lifecycle]);
     useEffect(() => { if (editor && !editor.isDestroyed)
         updatePreservedMarkdownLabels(editor.view.dom, text); }, [editor, text]);
@@ -264,6 +272,12 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
     const outcome = state.save.kind === 'settled' ? state.save.result : null;
     const uncertain = outcome?.kind === 'unknown';
     const conflict = outcome?.kind === 'conflict' || state.remote !== null;
+    // The receipt stays while the next save is on its way, and goes once the text came from somewhere else.
+    const receipt = useRef(null);
+    if (outcome?.kind === 'saved')
+        receipt.current = outcome.ref.revision;
+    else if (state.save.kind !== 'pending')
+        receipt.current = null;
     /** Shows a refused save or accept; the buffer keeps the text. */
     const report = (result) => {
         if (active.current !== controller || !result || typeof result !== 'object')
@@ -275,6 +289,7 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
             setError(typeof reason === 'string' && reason ? reason : kind === 'conflict' ? text.conflictFallback : text.saveFallback);
     };
     const saving = useMarkdownAutosave(controller, autosave, result => { report(result); onSaveResult?.(result); });
+    useMarkdownTabPoke(controller, crossTabRefresh);
     useEffect(() => { onAutosaveChange?.(saving.enabled ? saving.immediate : null); return () => onAutosaveChange?.(null); }, [onAutosaveChange, saving.enabled, saving.immediate]);
     const save = () => {
         setError(null);
@@ -349,7 +364,8 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
                                             setError(result.reason);
                                     }).catch(() => { if (active.current === controller)
                                         setError(text.headingNotSelected); });
-                            }, children: heading.text || text.untitledHeading }) }, heading.position)) }) }), uncertain && _jsxs("div", { role: "alert", className: "boring-markdown-alert", children: [text.uncertainNotice, _jsx(Control, { type: "button", onClick: () => run(controller.actions.reconcile), children: text.checkSaveOutcome }), _jsx(Control, { type: "button", onClick: () => run(controller.actions.abandon), children: text.stopChecking })] }), conflict && _jsxs("div", { role: "alert", className: "boring-markdown-alert", children: [text.conflictNotice, _jsx(Control, { type: "button", disabled: pending || uncertain, onClick: () => run(controller.actions.refresh), children: text.checkSavedVersion }), _jsx(Control, { type: "button", disabled: pending || uncertain, onClick: () => run(controller.actions.discardToRemote), children: text.discardLocal })] }), (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 || text.proposedEdit }), _jsxs("details", { children: [_jsx("summary", { children: text.reviewChanges }), _jsx(MarkdownProposalDiff, { components: components, proposal: proposal, labels: text }), _jsxs("details", { children: [_jsx("summary", { children: text.exactBeforeAfter }), _jsx("h4", { children: text.before }), _jsx("pre", { children: proposal.before }), _jsx("h4", { children: text.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 ? text.adopted : text.acceptAndSave }), _jsx(Control, { type: "button", onClick: () => controller.actions.reject(proposal.id), children: text.dismissProposal })] }, proposal.id)), mode === 'source'
+                            }, children: heading.text || text.untitledHeading }) }, heading.position)) }) }), uncertain && _jsxs("div", { role: "alert", className: "boring-markdown-alert", children: [text.uncertainNotice, _jsx(Control, { type: "button", onClick: () => run(controller.actions.reconcile), children: text.checkSaveOutcome }), _jsx(Control, { type: "button", onClick: () => run(controller.actions.abandon), children: text.stopChecking })] }), conflict && _jsx(MarkdownConflictChoices, { controller: controller, state: state, labels: text, components: components, disabled: pending || uncertain, readOnly: state.readOnly, setError: setError, run: run, onSaveResult: result => { if (result.kind !== 'conflict')
+                    report(result); onSaveResult?.(result); } }), receipt.current !== null && !conflict && _jsx("p", { className: "boring-markdown-notice", "data-testid": "markdown-save-receipt", "data-revision": receipt.current, title: receipt.current, children: text.savedRevision(receipt.current.slice(0, 8)) }), (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 || text.proposedEdit }), _jsxs("details", { children: [_jsx("summary", { children: text.reviewChanges }), _jsx(MarkdownProposalDiff, { components: components, proposal: proposal, labels: text }), _jsxs("details", { children: [_jsx("summary", { children: text.exactBeforeAfter }), _jsx("h4", { children: text.before }), _jsx("pre", { children: proposal.before }), _jsx("h4", { children: text.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 ? text.adopted : text.acceptAndSave }), _jsx(Control, { type: "button", onClick: () => controller.actions.reject(proposal.id), children: text.dismissProposal })] }, proposal.id)), mode === 'source'
                 ? _jsx(Source, { ref: sourceInput, className: "boring-markdown-source", "aria-label": text.sourceName(title), placeholder: placeholder, 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'))

package/dist/markdown-proposal-diff.d.ts

@@ -1,8 +1,9 @@
 import type { MarkdownProposal } from './markdown.js';
 import { type MarkdownEditorLabels } from './markdown-editor-labels.js';
-export declare function MarkdownProposalDiff({ components, proposal, labels }: {
+export declare function MarkdownProposalDiff({ components, proposal, name, labels }: {
     readonly components?: import('./viewer-components.js').ViewerComponents | undefined;
-    readonly proposal: MarkdownProposal;
+    readonly proposal: Pick<MarkdownProposal, 'before' | 'after'>;
+    readonly name?: string | undefined;
     readonly labels?: MarkdownEditorLabels;
 }): import("react").JSX.Element;
 //# sourceMappingURL=markdown-proposal-diff.d.ts.map

package/dist/markdown-proposal-diff.js

@@ -108,12 +108,12 @@ function DiffRow({ line, labels }) {
     const display = terminated ? line.value.slice(0, -1) : line.value;
     return _jsxs("div", { "data-diff": line.kind, "data-line-ending": terminated ? 'lf' : 'none', children: [_jsx("span", { children: line.kind === 'add' ? '+ ' : line.kind === 'remove' ? '- ' : '  ' }), _jsx("span", { "data-diff-text": "", children: display }), line.kind !== 'same' && line.value.endsWith('\r\n') && _jsxs("span", { "data-diff-crlf": "", children: [" ", labels.crlfLineEnding] }), !terminated && _jsxs("span", { "data-diff-no-newline": "", children: [" ", labels.noNewline] })] });
 }
-export function MarkdownProposalDiff({ components, proposal, labels = markdownEditorLabels.en }) {
+export function MarkdownProposalDiff({ components, proposal, name, labels = markdownEditorLabels.en }) {
     const Control = components?.button ?? 'button';
     const diff = useMemo(() => review(proposal.before, proposal.after), [proposal.before, proposal.after]);
     const shown = useMemo(() => entries(diff.lines), [diff]);
     const [expanded, setExpanded] = useState(() => new Set());
-    return _jsxs("div", { "data-boring": "proposal-diff", role: "group", "aria-label": labels.proposedLineChanges, children: [diff.fallback && _jsx("p", { role: "status", "data-diff-fallback": "", children: labels.diffFallback }), proposal.before === proposal.after && _jsx("p", { children: labels.noTextChanges }), _jsx("div", { style: { overflowX: 'auto', whiteSpace: 'pre-wrap' }, children: shown.map((entry, index) => entry.kind === 'fold' ? _jsxs("div", { children: [_jsx(Control, { type: "button", "data-diff-fold": "", "aria-expanded": expanded.has(entry.index), onClick: () => setExpanded(current => {
+    return _jsxs("div", { "data-boring": "proposal-diff", role: "group", "aria-label": name ?? labels.proposedLineChanges, children: [diff.fallback && _jsx("p", { role: "status", "data-diff-fallback": "", children: labels.diffFallback }), proposal.before === proposal.after && _jsx("p", { children: labels.noTextChanges }), _jsx("div", { style: { overflowX: 'auto', whiteSpace: 'pre-wrap' }, children: shown.map((entry, index) => entry.kind === 'fold' ? _jsxs("div", { children: [_jsx(Control, { type: "button", "data-diff-fold": "", "aria-expanded": expanded.has(entry.index), onClick: () => setExpanded(current => {
                                 const next = new Set(current);
                                 if (next.has(entry.index))
                                     next.delete(entry.index);

package/dist/markdown-safety.d.ts

@@ -10,10 +10,16 @@ export declare function normalizeMarkdownWhitespace(text: string): string;
 export declare function trailingWhitespace(text: string): string;
 /** The text a rich edit publishes: the serialised document, whitespace normalised, with the original's trailing newline. */
 export declare function finishRichMarkdown(serialized: string, previous: string): string;
+/** Above this many UTF-8 bytes a note opens as source: parsing it into the rich editor would stall the tab on every change. */
+export declare const MARKDOWN_RICH_SIZE_LIMIT: number;
+/** A UTF-16 unit is one to three UTF-8 bytes, so most lengths answer without encoding the text. */
+export declare function markdownExceedsRichSize(text: string, maxBytes?: number): boolean;
 /**
  * Verifies a native projection and its exact source spans. Unchanged blocks retain their source, and unsupported constructs are
  * inert atoms. The legacy whitespace comparison remains for empty/nbsp-only layout. Without a DOM only encoding can be checked.
  */
-export declare function checkMarkdownRichSafety(text: string): MarkdownRichSafety;
+export declare function checkMarkdownRichSafety(text: string, options?: {
+    readonly maxBytes?: number;
+}): MarkdownRichSafety;
 export declare function describeUnsafe(safety: MarkdownRichSafety): string;
 //# sourceMappingURL=markdown-safety.d.ts.map

package/dist/markdown-safety.js

@@ -1,6 +1,7 @@
 import { Editor } from '@tiptap/core';
 import { createMarkdownExtensions } from './markdown-extensions.js';
 import { captureMarkdownSource } from './markdown-source.js';
+import { MARKDOWN_TOO_LARGE_REASON } from './markdown-editor-labels.js';
 const FENCE = /^ {0,3}(```|~~~)/;
 /** Blank-line runs outside fenced code collapse to one blank line, and the ends are trimmed: the only whitespace the rich editor may normalise. */
 export function normalizeMarkdownWhitespace(text) {
@@ -79,14 +80,27 @@ function namedReasons(text) {
         reasons.push('NUL characters');
     return reasons;
 }
+/** Above this many UTF-8 bytes a note opens as source: parsing it into the rich editor would stall the tab on every change. */
+export const MARKDOWN_RICH_SIZE_LIMIT = 512 * 1024;
+const TOO_LARGE = Object.freeze({ safe: false, reasons: Object.freeze([MARKDOWN_TOO_LARGE_REASON]) });
+/** A UTF-16 unit is one to three UTF-8 bytes, so most lengths answer without encoding the text. */
+export function markdownExceedsRichSize(text, maxBytes = MARKDOWN_RICH_SIZE_LIMIT) {
+    if (text.length > maxBytes)
+        return true;
+    if (text.length * 3 <= maxBytes)
+        return false;
+    return new TextEncoder().encode(text).byteLength > maxBytes;
+}
 const cache = new Map();
 /**
  * Verifies a native projection and its exact source spans. Unchanged blocks retain their source, and unsupported constructs are
  * inert atoms. The legacy whitespace comparison remains for empty/nbsp-only layout. Without a DOM only encoding can be checked.
  */
-export function checkMarkdownRichSafety(text) {
+export function checkMarkdownRichSafety(text, options = {}) {
     if (text === '')
         return { safe: true };
+    if (markdownExceedsRichSize(text, options.maxBytes))
+        return TOO_LARGE;
     const known = cache.get(text);
     if (known)
         return known;
@@ -116,5 +130,7 @@ export function checkMarkdownRichSafety(text) {
 export function describeUnsafe(safety) {
     if (safety.safe)
         return '';
+    if (safety.reasons.includes(MARKDOWN_TOO_LARGE_REASON))
+        return 'Rich editing is off because this document is too large for it. You can still edit the Markdown source.';
     return `Rich editing is off because this document contains ${safety.reasons.join(', ')}, which it could not keep exactly. You can still edit the Markdown source.`;
 }

package/dist/markdown-tab-poke.d.ts

@@ -0,0 +1,7 @@
+import type { MarkdownController } from './markdown.js';
+/**
+ * Optional nudge between tabs of one note in one browser. A saved revision goes out and the receiver only runs its existing refresh,
+ * which never overwrites unsaved text and never saves, so a poke cannot start another one. No document text crosses the channel.
+ */
+export declare function useMarkdownTabPoke(controller: MarkdownController, enabled: boolean): void;
+//# sourceMappingURL=markdown-tab-poke.d.ts.map

package/dist/markdown-tab-poke.js

@@ -0,0 +1,57 @@
+import { useEffect } from 'react';
+function channelName({ base: { target: { resource, view } }, identity }) {
+    return `boring-markdown:${JSON.stringify([identity.scopeId, resource.providerId, resource.path, view.kind, view.kind === 'working' ? view.viewId : null])}`;
+}
+/**
+ * Optional nudge between tabs of one note in one browser. A saved revision goes out and the receiver only runs its existing refresh,
+ * which never overwrites unsaved text and never saves, so a poke cannot start another one. No document text crosses the channel.
+ */
+export function useMarkdownTabPoke(controller, enabled) {
+    useEffect(() => {
+        const Channel = globalThis.BroadcastChannel;
+        if (!enabled || typeof Channel !== 'function')
+            return;
+        const opening = controller.getSnapshot();
+        if (opening.lifecycle !== 'active')
+            return;
+        let channel;
+        try {
+            channel = new Channel(channelName(opening));
+        }
+        catch {
+            return;
+        }
+        // A listening channel must not hold a server-side process open.
+        channel.unref?.();
+        const receive = (event) => {
+            const revision = event.data?.revision;
+            const state = controller.getSnapshot();
+            if (typeof revision !== 'string' || state.lifecycle !== 'active')
+                return;
+            const known = (expectation) => expectation?.kind === 'revision' && expectation.target.revision === revision;
+            if (known(state.base) || known(state.remote))
+                return;
+            void controller.actions.refresh().catch(() => { });
+        };
+        channel.addEventListener('message', receive);
+        let announced = opening.save;
+        const stop = controller.subscribe(() => {
+            const { save } = controller.getSnapshot();
+            if (save === announced || save.kind !== 'settled' || save.result.kind !== 'saved')
+                return;
+            announced = save;
+            try {
+                channel.postMessage({ revision: save.result.ref.revision });
+            }
+            catch { /* A tab that cannot tell the others still saved. */ }
+        });
+        return () => {
+            stop();
+            channel.removeEventListener('message', receive);
+            try {
+                channel.close();
+            }
+            catch { /* Nothing is left to stop. */ }
+        };
+    }, [controller, enabled]);
+}

package/dist/markdown.d.ts

@@ -1,6 +1,7 @@
 import type { ReadResult, ResourceAccess, ResourceClient, ResourceExpectation, ResourceLocator, ResourceSnapshot } from '@hachej/boring-files';
 import { type TextEdit } from '@hachej/boring-files/text';
 import type { PresentationCommand, PresentationResult } from './contracts.js';
+import { type TextBufferRemote } from './text-buffer.js';
 import type { EditableViewerController, SaveResult, SaveSelection } from './resources.js';
 import type { TextDraftActions, TextDraftOptions, TextDraftRecoveryState } from './text-draft-types.js';
 export type MarkdownSource = {
@@ -68,7 +69,12 @@ export interface MarkdownActions extends TextDraftActions {
     /** For an unconfirmed save: stop reconciling and refresh, keeping the draft. The save is never reported committed or replayed. */
     readonly abandon: () => Promise<ReadResult>;
     readonly discardToRemote: () => Promise<ReadResult>;
+    /** Keeps the local text over the remote revision already shown and saves it conditionally. A remote that moved since is a new conflict, never an overwrite. */
+    readonly keepLocal: () => Promise<SaveResult>;
+    /** Reads the current saved text for review. The local text and base stay; what the editor knows of the remote moves to the revision returned, so `keepLocal` acts on it. */
+    readonly readRemote: () => Promise<MarkdownRemote>;
 }
+export type MarkdownRemote = TextBufferRemote;
 export interface MarkdownOptions {
     readonly drafts?: TextDraftOptions;
     /** Expected authenticated identity is comparison metadata, never a grant. */