@hachej/boring-ui-kit 0.4.26 → 0.4.28

package/dist/markdown-editor.js

@@ -10,12 +10,15 @@ 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, describeUnsafe, finishRichMarkdown } from './markdown-safety.js';
+import { checkMarkdownRichSafety, finishRichMarkdown } 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';
+export { markdownEditorLabels } from './markdown-editor-labels.js';
 /** Borrows the controller. The host owns document selection, access and disposal. */
 export function MarkdownEditor(props) {
     const active = useRef(props.controller);
@@ -65,10 +68,6 @@ function useKeyboardInset(active) {
     }, [active]);
     return inset;
 }
-const menuLabels = {
-    en: { moreActions: 'More actions', editorMode: 'Editor mode', formatted: 'Formatted', markdown: 'Markdown', showOutline: 'Show outline' },
-    fr: { moreActions: 'Plus d’actions', editorMode: 'Mode d’édition', formatted: 'Mis en forme', markdown: 'Markdown', showOutline: 'Afficher le plan' },
-};
 /** Unstyled native fallback. Installed recipes bind the host's shadcn dropdown. */
 function NativeMarkdownViewOptions({ labels, mode, onModeChange, richDisabledReason, outline, input }) {
     const InputControl = input ?? 'input';
@@ -78,7 +77,10 @@ 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 = 'Document', initialMode = 'rich', placeholder = 'Start writing', className, onMountedTools, header = true, showOutline = header, mode: controlledMode, onModeChange, onRichSafety, resolveImage, formattingToolbar = 'selection', locale = 'en', 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, activeController: active }) {
+    const text = useMemo(() => resolveMarkdownEditorLabels(locale, labelOverrides), [locale, labelOverrides]);
+    const title = titleProp ?? text.defaultTitle;
+    const placeholder = placeholderProp ?? text.defaultPlaceholder;
     const Control = components?.button ?? 'button';
     const FormattingControl = components?.formattingControl ?? 'button';
     const Bubble = components?.bubble ?? Fragment;
@@ -107,6 +109,10 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
     activeMode.current = mode;
     const images = useRef(resolveImage);
     images.current = resolveImage;
+    const preservedLabels = useRef(text);
+    preservedLabels.current = text;
+    const richPlaceholder = useRef(placeholder);
+    richPlaceholder.current = placeholder;
     useEffect(() => { onRichSafety?.(safety); }, [safety, onRichSafety]);
     const [error, setError] = useState(null);
     const interaction = useRef(false);
@@ -120,10 +126,10 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
     };
     const editor = useEditor({
         immediatelyRender: false,
-        extensions: createMarkdownExtensions({ placeholder, images: () => images.current, source: () => controller.getSnapshot().text.replace(/\r\n/g, '\n') }),
+        extensions: createMarkdownExtensions({ placeholder: () => richPlaceholder.current, images: () => images.current, preservedLabels: () => preservedLabels.current, source: () => controller.getSnapshot().text.replace(/\r\n/g, '\n') }),
         content: '',
         editable: !state.readOnly && state.lifecycle === 'active',
-        editorProps: { attributes: { role: 'textbox', 'aria-label': `${title} rich text`, 'aria-multiline': 'true', tabindex: '0', class: 'boring-markdown-content' } },
+        editorProps: { attributes: { role: 'textbox', 'aria-label': text.richName(title), 'aria-multiline': 'true', tabindex: '0', class: 'boring-markdown-content' } },
         onUpdate: ({ editor: current, transaction }) => {
             if (active.current !== controller || !interaction.current || !transaction.docChanged || controller.getSnapshot().lifecycle !== 'active' || controller.getSnapshot().readOnly)
                 return;
@@ -154,6 +160,10 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
         projected.current = state.text;
     }, [editor, 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]);
+    useEffect(() => { if (editor && !editor.isDestroyed)
+        editor.view.dispatch(editor.state.tr.setMeta('addToHistory', false)); }, [editor, placeholder]);
     const mounted = useMemo(() => {
         if (mode === 'rich' && !editor)
             return null;
@@ -262,7 +272,7 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
         if (kind === 'saved')
             setError(null);
         if (kind === 'denied' || kind === 'conflict' || kind === 'unavailable' || kind === 'file_too_large')
-            setError(typeof reason === 'string' && reason ? reason : kind === 'conflict' ? 'The document changed elsewhere. Your text is still available.' : 'The document could not be saved. Your text is still available.');
+            setError(typeof reason === 'string' && reason ? reason : kind === 'conflict' ? text.conflictFallback : text.saveFallback);
     };
     const saving = useMarkdownAutosave(controller, autosave, result => { report(result); onSaveResult?.(result); });
     useEffect(() => { onAutosaveChange?.(saving.enabled ? saving.immediate : null); return () => onAutosaveChange?.(null); }, [onAutosaveChange, saving.enabled, saving.immediate]);
@@ -272,12 +282,12 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
             void saving.manual();
         else
             void controller.flush(controller.actions.selection()).then(report, () => { if (active.current === controller)
-                setError('The save could not be completed. Your text is still available.'); });
+                setError(text.saveFailed); });
     };
     const run = (operation) => {
         setError(null);
         void operation().then(report, () => { if (active.current === controller)
-            setError('The operation could not be completed. Your text is still available.'); });
+            setError(text.operationFailed); });
     };
     const richOnly = unavailable || mode === 'source' || !editor;
     const [linkDraft, setLinkDraft] = useState(null);
@@ -309,9 +319,9 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
         command(() => href === '' ? chain().extendMarkRange('link').unsetLink().run() : chain().extendMarkRange('link').setLink({ href }).run());
         setLinkDraft(null);
     };
-    const formatTools = _jsxs(_Fragment, { children: [tool('Bold', 'Bold', marks?.bold, () => chain().toggleBold().run()), tool('Italic', 'Italic', marks?.italic, () => chain().toggleItalic().run()), tool('Strikethrough', 'Strike', marks?.strike, () => chain().toggleStrike().run()), tool('Highlight', 'Highlight', marks?.highlight, () => chain().toggleHighlight().run()), tool('Code', 'Code', marks?.code, () => chain().toggleCode().run()), separator, tool('Heading 1', 'Heading1', marks?.h1, () => chain().toggleHeading({ level: 1 }).run()), tool('Heading 2', 'Heading2', marks?.h2, () => chain().toggleHeading({ level: 2 }).run()), tool('Heading 3', 'Heading3', marks?.h3, () => chain().toggleHeading({ level: 3 }).run()), separator, tool('Bullet list', 'BulletList', marks?.bullet, () => chain().toggleBulletList().run()), tool('Numbered list', 'OrderedList', marks?.ordered, () => chain().toggleOrderedList().run()), tool('Task list', 'TaskList', marks?.task, () => chain().toggleTaskList().run()), separator, tool('Quote', 'Quote', marks?.quote, () => chain().toggleBlockquote().run()), tool('Code block', 'CodeBlock', marks?.codeBlock, () => chain().toggleCodeBlock().run()), tool('Link', 'Link', marks?.link || linkDraft !== null, openLink), tool('Table', 'Table', marks?.table, () => marks?.table ? chain().deleteTable().run() : chain().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run()), tool('Horizontal rule', 'Rule', false, () => chain().setHorizontalRule().run()), marks?.table && _jsxs(_Fragment, { children: [separator, tool('Add table row', 'Rows', false, () => chain().addRowAfter().run()), tool('Add table column', 'Columns', false, () => chain().addColumnAfter().run()), tool('Delete table', 'Trash', false, () => chain().deleteTable().run())] })] });
+    const formatTools = _jsxs(_Fragment, { children: [tool(text.bold, 'Bold', marks?.bold, () => chain().toggleBold().run()), tool(text.italic, 'Italic', marks?.italic, () => chain().toggleItalic().run()), tool(text.strike, 'Strike', marks?.strike, () => chain().toggleStrike().run()), tool(text.highlight, 'Highlight', marks?.highlight, () => chain().toggleHighlight().run()), tool(text.code, 'Code', marks?.code, () => chain().toggleCode().run()), separator, tool(text.heading(1), 'Heading1', marks?.h1, () => chain().toggleHeading({ level: 1 }).run()), tool(text.heading(2), 'Heading2', marks?.h2, () => chain().toggleHeading({ level: 2 }).run()), tool(text.heading(3), 'Heading3', marks?.h3, () => chain().toggleHeading({ level: 3 }).run()), separator, tool(text.bulletList, 'BulletList', marks?.bullet, () => chain().toggleBulletList().run()), tool(text.numberedList, 'OrderedList', marks?.ordered, () => chain().toggleOrderedList().run()), tool(text.taskList, 'TaskList', marks?.task, () => chain().toggleTaskList().run()), separator, tool(text.quote, 'Quote', marks?.quote, () => chain().toggleBlockquote().run()), tool(text.codeBlock, 'CodeBlock', marks?.codeBlock, () => chain().toggleCodeBlock().run()), tool(text.link, 'Link', marks?.link || linkDraft !== null, openLink), tool(text.table, 'Table', marks?.table, () => marks?.table ? chain().deleteTable().run() : chain().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run()), tool(text.horizontalRule, 'Rule', false, () => chain().setHorizontalRule().run()), marks?.table && _jsxs(_Fragment, { children: [separator, tool(text.addTableRow, 'Rows', false, () => chain().addRowAfter().run()), tool(text.addTableColumn, 'Columns', false, () => chain().addColumnAfter().run()), tool(text.deleteTable, 'Trash', false, () => chain().deleteTable().run())] })] });
     const viewOptions = {
-        labels: menuLabels[locale], mode, onModeChange: switchMode, richDisabledReason: richOffered ? undefined : describeUnsafe(safety),
+        labels: text, mode, onModeChange: switchMode, richDisabledReason: richOffered || safety.safe ? undefined : text.richOff(safety.reasons),
         outline: showOutline ? { shown: outlineShown, onChange: setOutlineShown } : undefined,
     };
     return _jsxs("section", { className: className, "data-boring": "markdown-editor", "data-mode": mode, "data-dock": (mode === 'rich' && dockVisible) || undefined, "data-dirty": state.dirty || undefined, onBlurCapture: event => { if (saving.enabled && !event.currentTarget.contains(event.relatedTarget))
@@ -321,11 +331,11 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
                 if (!unavailable && !uncertain)
                     save();
             }
-        }, children: [header && _jsxs("header", { children: [_jsx("strong", { children: title }), state.readOnly && _jsx("span", { children: "Read only" }), _jsx("span", { role: "status", children: state.lifecycle === 'disposed' ? 'Closed' : pending ? 'Saving…' : uncertain ? 'Save unconfirmed' : conflict ? 'Changed elsewhere' : state.dirty ? 'Unsaved changes' : 'Saved' }), ViewOptions ? _jsx(ViewOptions, { ...viewOptions }) : _jsx(NativeMarkdownViewOptions, { ...viewOptions, input: components?.input }), mode === 'rich' && _jsx(FormattingControl, { type: "button", "aria-label": locale === 'fr' ? 'Mise en forme' : 'Formatting', title: locale === 'fr' ? 'Mise en forme' : 'Formatting', "aria-pressed": toolbar === 'pinned', onClick: () => setToolbar(toolbar === 'pinned' ? 'selection' : 'pinned'), children: _jsx(MarkdownIcon, { name: "Type" }) }), !saving.enabled && _jsx(Control, { type: "button", disabled: unavailable || !state.dirty || pending || uncertain, onClick: save, children: "Save" })] }), _jsx(TextDraftControls, { components: components, recovery: state.recovery, actions: controller.actions, readOnly: state.readOnly, blocked: state.lifecycle !== 'active' || state.save.kind === 'pending' || (state.save.kind === 'settled' && state.save.result.kind === 'unknown') }), mode === 'rich' && showPinned && _jsx("div", { role: "toolbar", "aria-label": "Text formatting", className: "boring-markdown-toolbar", children: formatTools }), mode === 'rich' && dockVisible && createPortal(_jsxs("div", { role: "toolbar", "aria-label": "Text formatting", className: "boring-viewer boring-markdown-dock", "data-testid": "markdown-dock", "data-keyboard": keyboardInset > 0 || undefined, style: { bottom: keyboardInset }, onPointerDown: event => event.preventDefault(), children: [Rule && _jsx(Rule, { className: "boring-markdown-dock-rule" }), formatTools] }), document.body), mode === 'rich' && editor && !showPinned && !unavailable && _jsx(BubbleMenu, { editor: editor, updateDelay: 0, options: BUBBLE_OPTIONS, appendTo: bubbleContainer, role: "toolbar", "aria-label": "Text formatting", className: "boring-viewer boring-markdown-bubble", children: _jsxs(Bubble, { children: [tool('Bold', 'Bold', marks?.bold, () => chain().toggleBold().run()), tool('Italic', 'Italic', marks?.italic, () => chain().toggleItalic().run()), tool('Highlight', 'Highlight', marks?.highlight, () => chain().toggleHighlight().run()), tool('Code', 'Code', marks?.code, () => chain().toggleCode().run()), tool('Link', 'Link', marks?.link || linkDraft !== null, openLink)] }) }), mode === 'rich' && linkDraft !== null && _jsxs("form", { className: "boring-markdown-link", "aria-label": "Link address", onSubmit: event => { event.preventDefault(); applyLink(); }, children: [_jsx(LinkInput, { type: "text", inputMode: "url", autoFocus: true, "aria-label": "Link address", placeholder: "https://", value: linkDraft, onChange: event => setLinkDraft(event.currentTarget.value), onKeyDown: event => { if (event.key === 'Escape') {
+        }, children: [header && _jsxs("header", { children: [_jsx("strong", { children: title }), state.readOnly && _jsx("span", { children: text.readOnly }), _jsx("span", { role: "status", children: state.lifecycle === 'disposed' ? text.closed : pending ? text.saving : uncertain ? text.saveUnconfirmed : conflict ? text.changedElsewhere : state.dirty ? text.unsaved : text.saved }), ViewOptions ? _jsx(ViewOptions, { ...viewOptions }) : _jsx(NativeMarkdownViewOptions, { ...viewOptions, input: components?.input }), mode === 'rich' && _jsx(FormattingControl, { type: "button", "aria-label": text.formatting, title: text.formatting, "aria-pressed": toolbar === 'pinned', onClick: () => setToolbar(toolbar === 'pinned' ? 'selection' : 'pinned'), children: _jsx(MarkdownIcon, { name: "Type" }) }), !saving.enabled && _jsx(Control, { type: "button", disabled: unavailable || !state.dirty || pending || uncertain, onClick: save, children: text.save })] }), _jsx(TextDraftControls, { labels: text, components: components, recovery: state.recovery, actions: controller.actions, readOnly: state.readOnly, blocked: state.lifecycle !== 'active' || state.save.kind === 'pending' || (state.save.kind === 'settled' && state.save.result.kind === 'unknown') }), mode === 'rich' && showPinned && _jsx("div", { role: "toolbar", "aria-label": text.textFormatting, className: "boring-markdown-toolbar", children: formatTools }), mode === 'rich' && dockVisible && createPortal(_jsxs("div", { role: "toolbar", "aria-label": text.textFormatting, className: "boring-viewer boring-markdown-dock", "data-testid": "markdown-dock", "data-keyboard": keyboardInset > 0 || undefined, style: { bottom: keyboardInset }, onPointerDown: event => event.preventDefault(), children: [Rule && _jsx(Rule, { className: "boring-markdown-dock-rule" }), formatTools] }), document.body), mode === 'rich' && editor && !showPinned && !unavailable && _jsx(BubbleMenu, { editor: editor, updateDelay: 0, options: BUBBLE_OPTIONS, appendTo: bubbleContainer, role: "toolbar", "aria-label": text.textFormatting, className: "boring-viewer boring-markdown-bubble", children: _jsxs(Bubble, { children: [tool(text.bold, 'Bold', marks?.bold, () => chain().toggleBold().run()), tool(text.italic, 'Italic', marks?.italic, () => chain().toggleItalic().run()), tool(text.highlight, 'Highlight', marks?.highlight, () => chain().toggleHighlight().run()), tool(text.code, 'Code', marks?.code, () => chain().toggleCode().run()), tool(text.link, 'Link', marks?.link || linkDraft !== null, openLink)] }) }), mode === 'rich' && linkDraft !== null && _jsxs("form", { className: "boring-markdown-link", "aria-label": text.linkAddress, onSubmit: event => { event.preventDefault(); applyLink(); }, children: [_jsx(LinkInput, { type: "text", inputMode: "url", autoFocus: true, "aria-label": text.linkAddress, placeholder: "https://", value: linkDraft, onChange: event => setLinkDraft(event.currentTarget.value), onKeyDown: event => { if (event.key === 'Escape') {
                             event.preventDefault();
                             setLinkDraft(null);
                             editor?.commands.focus();
-                        } } }), _jsx(Control, { type: "submit", children: linkDraft.trim() === '' && marks?.link ? 'Remove link' : 'Apply link' }), _jsx(Control, { type: "button", onClick: () => { setLinkDraft(null); editor?.commands.focus(); }, children: "Cancel" })] }), !richOffered && _jsx("p", { role: "note", className: "boring-markdown-notice", "data-testid": "markdown-source-only", children: describeUnsafe(safety) }), showOutline && outlineShown && mode === 'rich' && outline && outline.headings.length > 0 && _jsx("nav", { "aria-label": "Document outline", children: _jsx("ol", { children: outline.headings.map((heading, index) => _jsx("li", { "data-heading-level": heading.level, children: _jsx(Control, { type: "button", "aria-label": `Go to heading: ${heading.text || 'Untitled heading'}`, disabled: state.lifecycle !== 'active', onClick: () => {
+                        } } }), _jsx(Control, { type: "submit", children: linkDraft.trim() === '' && marks?.link ? text.removeLink : text.applyLink }), _jsx(Control, { type: "button", onClick: () => { setLinkDraft(null); editor?.commands.focus(); }, children: text.cancel })] }), !richOffered && _jsx("p", { role: "note", className: "boring-markdown-notice", "data-testid": "markdown-source-only", children: safety.safe ? '' : text.richOff(safety.reasons) }), showOutline && outlineShown && mode === 'rich' && outline && outline.headings.length > 0 && _jsx("nav", { "aria-label": text.documentOutline, children: _jsx("ol", { children: outline.headings.map((heading, index) => _jsx("li", { "data-heading-level": heading.level, children: _jsx(Control, { type: "button", "aria-label": text.goToHeading(heading.text || text.untitledHeading), disabled: state.lifecycle !== 'active', onClick: () => {
                                 if (!editor || editor.isDestroyed || active.current !== controller || controller.getSnapshot().lifecycle !== 'active'
                                     || controller.getSnapshot().bufferVersion !== state.bufferVersion || editor.state.doc !== outline.document)
                                     return;
@@ -338,9 +348,9 @@ function MarkdownEditorSession({ highlights, onQuoteSelection, onHighlightActiva
                                         if (active.current === controller && result.kind !== 'applied' && result.kind !== 'proposed')
                                             setError(result.reason);
                                     }).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, onSelect: event => onQuoteSelection?.(captureMarkdownQuote(state.text, { start: event.currentTarget.selectionStart, end: event.currentTarget.selectionEnd })), onChange: event => controller.actions.edit(event.currentTarget.value) })
+                                        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'
+                ? _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'))
                         event.preventDefault(); }, children: _jsx(EditorContent, { editor: editor }) })] });

package/dist/markdown-extensions.d.ts

@@ -1,11 +1,13 @@
 import type { Extensions } from '@tiptap/core';
+import { preservedMarkdownNodes } from './markdown-preserved.js';
 /** Maps an image address in the document to a URL the browser may load, or `undefined` to keep the image inert. */
 export type MarkdownImageResolver = (source: string) => string | undefined;
 /** Only an image carried inside the document itself loads by default. Anything else needs the host's resolver. */
 export declare const inlineImagesOnly: MarkdownImageResolver;
 export interface MarkdownExtensionOptions {
-    readonly placeholder?: string;
+    readonly placeholder?: string | (() => string);
     readonly images?: () => MarkdownImageResolver | undefined;
+    readonly preservedLabels?: Parameters<typeof preservedMarkdownNodes>[0];
     readonly source?: () => string;
 }
 /**
@@ -13,5 +15,5 @@ export interface MarkdownExtensionOptions {
  * strike, links), task lists, GFM tables, images and highlight. Underline is off because Markdown has no underline.
  * Images are inert: without a host resolver they render as a labelled placeholder and never make a request.
  */
-export declare function createMarkdownExtensions({ placeholder, images, source }?: MarkdownExtensionOptions): Extensions;
+export declare function createMarkdownExtensions({ placeholder, images, preservedLabels, source }?: MarkdownExtensionOptions): Extensions;
 //# sourceMappingURL=markdown-extensions.d.ts.map

package/dist/markdown-extensions.js

@@ -143,7 +143,7 @@ export const inlineImagesOnly = source => /^data:image\/(?:png|jpe?g|gif|webp);b
  * strike, links), task lists, GFM tables, images and highlight. Underline is off because Markdown has no underline.
  * Images are inert: without a host resolver they render as a labelled placeholder and never make a request.
  */
-export function createMarkdownExtensions({ placeholder, images, source = () => '' } = {}) {
+export function createMarkdownExtensions({ placeholder, images, preservedLabels, source = () => '' } = {}) {
     const InertImage = Image.extend({
         renderHTML({ node }) {
             const source = String(node.attrs['src'] ?? '');
@@ -161,7 +161,7 @@ export function createMarkdownExtensions({ placeholder, images, source = () => '
     });
     return [
         sourceStarterKit(source, () => schema).configure({ link: { openOnClick: false, autolink: false, linkOnPaste: false }, underline: false }),
-        ...preservedMarkdownNodes(),
+        ...preservedMarkdownNodes(preservedLabels),
         TaskList, TaskItem.configure({ nested: true }),
         SourceTable.configure({ resizable: false }), TableRow, TableHeader, TableCell,
         InertImage.configure({ inline: false, allowBase64: true }),

package/dist/markdown-preserved.d.ts

@@ -1,4 +1,8 @@
 import { Node } from '@tiptap/core';
+import { type MarkdownEditorLabels } from './markdown-editor-labels.js';
+type PreservedLabels = Pick<MarkdownEditorLabels, 'preservedBlockName' | 'frontMatterCode'>;
+export declare function updatePreservedMarkdownLabels(root: HTMLElement, labels: PreservedLabels): void;
 /** Literal Markdown, never HTML inserted into the host DOM. These atoms are host presentation, not Pi execution. */
-export declare function preservedMarkdownNodes(): Node<any, any>[];
+export declare function preservedMarkdownNodes(labels?: () => PreservedLabels): Node<any, any>[];
+export {};
 //# sourceMappingURL=markdown-preserved.d.ts.map

package/dist/markdown-preserved.js

@@ -1,14 +1,25 @@
 import { Node } from '@tiptap/core';
 import { Marked } from 'marked';
+import { markdownEditorLabels } from './markdown-editor-labels.js';
 const literalHtml = new Marked();
+export function updatePreservedMarkdownLabels(root, labels) {
+    for (const block of Array.from(root.querySelectorAll('[data-preserved]'))) {
+        const name = block.querySelector('small');
+        if (name)
+            name.textContent = labels.preservedBlockName(block.dataset['preserved'] ?? 'HTML');
+        const code = block.querySelector('[role="textbox"]');
+        if (code)
+            code.setAttribute('aria-label', labels.frontMatterCode);
+    }
+}
 /** Literal Markdown, never HTML inserted into the host DOM. These atoms are host presentation, not Pi execution. */
-export function preservedMarkdownNodes() {
+export function preservedMarkdownNodes(labels = () => markdownEditorLabels.en) {
     const block = Node.create({
         name: 'preservedBlock', group: 'block', atom: true,
         addAttributes: () => ({ raw: { default: '', rendered: false }, label: { default: 'HTML', rendered: false } }),
         parseHTML: () => [],
         renderHTML: ({ node }) => ['div', { class: 'boring-markdown-preserved', 'data-preserved': node.attrs['label'] },
-            ['small', {}, String(node.attrs['label'])], ['pre', {}, String(node.attrs['raw'])]],
+            ['small', {}, labels().preservedBlockName(String(node.attrs['label']))], ['pre', {}, String(node.attrs['raw'])]],
         markdownTokenName: 'preservedBlock',
         markdownTokenizer: {
             name: 'preservedBlock', level: 'block',
@@ -33,7 +44,7 @@ export function preservedMarkdownNodes() {
                 dom.className = 'boring-markdown-preserved';
                 dom.dataset['preserved'] = String(node.attrs['label']);
                 const label = document.createElement('small');
-                label.textContent = String(node.attrs['label']);
+                label.textContent = labels().preservedBlockName(String(node.attrs['label']));
                 dom.append(label);
                 if (node.attrs['label'] !== 'Front matter') {
                     const pre = document.createElement('pre');
@@ -45,7 +56,7 @@ export function preservedMarkdownNodes() {
                 code.textContent = String(node.attrs['raw']);
                 code.contentEditable = editor.isEditable ? 'plaintext-only' : 'false';
                 code.setAttribute('role', 'textbox');
-                code.setAttribute('aria-label', 'Front matter code');
+                code.setAttribute('aria-label', labels().frontMatterCode);
                 code.setAttribute('aria-multiline', 'true');
                 code.spellcheck = false;
                 dom.append(code);

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

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

package/dist/markdown-proposal-diff.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useMemo, useState } from 'react';
+import { markdownEditorLabels } from './markdown-editor-labels.js';
 const maxMatrixCells = 250_000;
 const contextLines = 2;
 function lineAt(values, index) {
@@ -102,22 +103,22 @@ function entries(diff) {
     }
     return result;
 }
-function DiffRow({ line }) {
+function DiffRow({ line, labels }) {
     const terminated = line.value.endsWith('\n');
     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') && _jsx("span", { "data-diff-crlf": "", children: " CRLF line ending" }), !terminated && _jsx("span", { "data-diff-no-newline": "", children: " No newline at end" })] });
+    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 }) {
+export function MarkdownProposalDiff({ components, proposal, 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": "Proposed line changes", children: [diff.fallback && _jsx("p", { role: "status", "data-diff-fallback": "", children: "Detailed line alignment unavailable; showing changed block." }), proposal.before === proposal.after && _jsx("p", { children: "No text changes" }), _jsx("div", { style: { overflowX: 'auto', whiteSpace: 'pre-wrap' }, children: shown.map((entry, index) => entry.kind === 'fold' ? _jsxs("div", { children: [_jsxs(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": 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);
                                 else
                                     next.add(entry.index);
                                 return next;
-                            }), children: [expanded.has(entry.index) ? 'Hide' : 'Show', " ", entry.lines.length, " unchanged lines"] }), expanded.has(entry.index) && entry.lines.map((line, lineIndex) => _jsx(DiffRow, { line: line }, lineIndex))] }, `fold-${entry.index}`) : _jsx(DiffRow, { line: entry }, `line-${index}`)) })] });
+                            }), children: expanded.has(entry.index) ? labels.hideUnchangedLines(entry.lines.length) : labels.showUnchangedLines(entry.lines.length) }), expanded.has(entry.index) && entry.lines.map((line, lineIndex) => _jsx(DiffRow, { line: line, labels: labels }, lineIndex))] }, `fold-${entry.index}`) : _jsx(DiffRow, { line: entry, labels: labels }, `line-${index}`)) })] });
 }

package/dist/text-draft-controls.d.ts

@@ -1,11 +1,15 @@
 import type { TextDraftActions, TextDraftRecoveryState } from './text-draft-types.js';
 import type { ViewerComponents } from './viewer-components.js';
+import { type TextDraftLabels } from './text-draft-labels.js';
+export type { TextDraftLabels } from './text-draft-labels.js';
 export interface TextDraftControlsProps {
     readonly components?: ViewerComponents | undefined;
     readonly recovery: TextDraftRecoveryState;
     readonly actions: TextDraftActions;
     readonly readOnly?: boolean;
     readonly blocked?: boolean;
+    /** Words of the panel. Defaults to English; a host passes the French set or its own. */
+    readonly labels?: TextDraftLabels;
 }
-export declare function TextDraftControls({ components, recovery, actions, readOnly, blocked }: TextDraftControlsProps): import("react").JSX.Element | null;
+export declare function TextDraftControls({ components, recovery, actions, readOnly, blocked, labels }: TextDraftControlsProps): import("react").JSX.Element | null;
 //# sourceMappingURL=text-draft-controls.d.ts.map

package/dist/text-draft-controls.js

@@ -1,7 +1,8 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useLayoutEffect, useRef, useState } from 'react';
-export function TextDraftControls({ components, recovery, actions, readOnly = false, blocked = false }) {
+import { textDraftLabels } from './text-draft-labels.js';
+export function TextDraftControls({ components, recovery, actions, readOnly = false, blocked = false, labels = textDraftLabels.en }) {
     const Control = components?.button ?? 'button';
     const owner = useRef({ actions, busy: false });
     const [pending, setPending] = useState(false);
@@ -20,15 +21,15 @@ export function TextDraftControls({ components, recovery, actions, readOnly = fa
         setNotice(undefined);
         void Promise.resolve().then(action).then(result => {
             if (owner.current === capturedOwner)
-                setNotice(result.reason ?? (result.kind === 'restored' ? 'Draft restored locally. Save to publish it.' : result.kind === 'discarded' ? 'Stored draft discarded. Current edits are unchanged.' : undefined));
+                setNotice(result.reason ?? (result.kind === 'restored' ? labels.draftRestored : result.kind === 'discarded' ? labels.draftDiscarded : undefined));
         }, () => { if (owner.current === capturedOwner)
-            setNotice('Draft storage unavailable. Current edits are unchanged.'); }).finally(() => { if (owner.current === capturedOwner) {
+            setNotice(labels.draftStorageFailed); }).finally(() => { if (owner.current === capturedOwner) {
             capturedOwner.busy = false;
             setPending(false);
         } ; });
     };
     const discovery = active ? recovery.discovery : undefined;
     const checkpoint = active ? recovery.checkpoint : undefined;
-    const status = !active ? `Draft recovery ${recovery.kind}` : discovery?.kind === 'checking' ? 'Checking stored drafts' : checkpoint?.kind === 'pending' ? 'Storing draft' : checkpoint?.kind === 'stored' ? 'Draft stored for recovery. Storage is not a save receipt.' : checkpoint?.kind === 'failed' ? 'Draft recovery storage unavailable' : 'Draft recovery enabled';
-    return _jsxs("section", { "data-boring": "text-draft-controls", "aria-label": "Draft recovery", children: [_jsx("p", { role: "status", children: status }), _jsx(Control, { type: "button", disabled: !active || pending || blocked || discovery?.kind === 'checking', onClick: () => run(actions.checkDrafts), children: "Check stored drafts" }), _jsx(Control, { type: "button", disabled: !active || pending || readOnly, onClick: () => run(actions.checkpointDraft), children: "Store draft for recovery" }), discovery?.kind === 'empty' && _jsx("p", { children: "No stored drafts" }), discovery && 'reason' in discovery && _jsx("p", { role: "alert", children: discovery.reason }), checkpoint?.kind === 'failed' && _jsx("p", { role: "alert", children: checkpoint.result.reason }), discovery?.kind === 'offered' && _jsxs(_Fragment, { children: [discovery.truncated && _jsx("p", { children: "More stored drafts exist than this listing shows." }), discovery.choices.map(choice => _jsxs("div", { role: "group", "aria-label": "Stored draft", children: [_jsx("p", { children: choice.compatibility === 'conflict' ? 'Saved revision changed. Review this draft separately.' : 'Stored draft matches the checked saved revision.' }), _jsxs("details", { children: [_jsx("summary", { children: "Review stored draft" }), _jsx("pre", { children: choice.text })] }), _jsx(Control, { type: "button", disabled: pending || blocked || readOnly || choice.compatibility !== 'exact', onClick: () => run(() => actions.restoreDraft(choice.selection)), children: "Restore draft" }), _jsx(Control, { type: "button", disabled: pending || blocked, onClick: () => run(() => actions.discardDraft(choice.selection)), children: "Discard stored draft" })] }, `${choice.selection.offerId}:${choice.selection.draft.writerId}:${choice.selection.draft.sequence}`))] }), notice && _jsx("p", { role: "alert", children: notice })] });
+    const status = !active ? labels.draftRecoveryState(recovery.kind) : discovery?.kind === 'checking' ? labels.draftChecking : checkpoint?.kind === 'pending' ? labels.draftStoring : checkpoint?.kind === 'stored' ? labels.draftStored : checkpoint?.kind === 'failed' ? labels.draftStorageUnavailable : labels.draftEnabled;
+    return _jsxs("section", { "data-boring": "text-draft-controls", "aria-label": labels.draftRecovery, children: [_jsx("p", { role: "status", children: status }), _jsx(Control, { type: "button", disabled: !active || pending || blocked || discovery?.kind === 'checking', onClick: () => run(actions.checkDrafts), children: labels.checkStoredDrafts }), _jsx(Control, { type: "button", disabled: !active || pending || readOnly, onClick: () => run(actions.checkpointDraft), children: labels.storeDraft }), discovery?.kind === 'empty' && _jsx("p", { children: labels.noStoredDrafts }), discovery && 'reason' in discovery && _jsx("p", { role: "alert", children: discovery.reason }), checkpoint?.kind === 'failed' && _jsx("p", { role: "alert", children: checkpoint.result.reason }), discovery?.kind === 'offered' && _jsxs(_Fragment, { children: [discovery.truncated && _jsx("p", { children: labels.moreStoredDrafts }), discovery.choices.map(choice => _jsxs("div", { role: "group", "aria-label": labels.storedDraft, children: [_jsx("p", { children: choice.compatibility === 'conflict' ? labels.draftConflict : labels.draftMatches }), _jsxs("details", { children: [_jsx("summary", { children: labels.reviewStoredDraft }), _jsx("pre", { children: choice.text })] }), _jsx(Control, { type: "button", disabled: pending || blocked || readOnly || choice.compatibility !== 'exact', onClick: () => run(() => actions.restoreDraft(choice.selection)), children: labels.restoreDraft }), _jsx(Control, { type: "button", disabled: pending || blocked, onClick: () => run(() => actions.discardDraft(choice.selection)), children: labels.discardStoredDraft })] }, `${choice.selection.offerId}:${choice.selection.draft.writerId}:${choice.selection.draft.sequence}`))] }), notice && _jsx("p", { role: "alert", children: notice })] });
 }

package/dist/text-draft-labels.d.ts

@@ -0,0 +1,26 @@
+/** The draft-recovery panel's words. English is the default; `locale="fr"` selects the French set; a host overrides any key. */
+export interface TextDraftLabels {
+    readonly draftRecovery: string;
+    /** `kind` is the recovery state when recovery is not active, e.g. `disabled`. */
+    readonly draftRecoveryState: (kind: string) => string;
+    readonly draftChecking: string;
+    readonly draftStoring: string;
+    readonly draftStored: string;
+    readonly draftStorageUnavailable: string;
+    readonly draftEnabled: string;
+    readonly checkStoredDrafts: string;
+    readonly storeDraft: string;
+    readonly noStoredDrafts: string;
+    readonly moreStoredDrafts: string;
+    readonly storedDraft: string;
+    readonly draftConflict: string;
+    readonly draftMatches: string;
+    readonly reviewStoredDraft: string;
+    readonly restoreDraft: string;
+    readonly discardStoredDraft: string;
+    readonly draftRestored: string;
+    readonly draftDiscarded: string;
+    readonly draftStorageFailed: string;
+}
+export declare const textDraftLabels: Record<'en' | 'fr', TextDraftLabels>;
+//# sourceMappingURL=text-draft-labels.d.ts.map

package/dist/text-draft-labels.js

@@ -0,0 +1,47 @@
+const frenchRecoveryStates = { disabled: 'désactivée', revoked: 'accès révoqué', expired: 'expirée', disposed: 'fermée' };
+export const textDraftLabels = {
+    en: {
+        draftRecovery: 'Draft recovery',
+        draftRecoveryState: kind => `Draft recovery ${kind}`,
+        draftChecking: 'Checking stored drafts',
+        draftStoring: 'Storing draft',
+        draftStored: 'Draft stored for recovery. Storage is not a save receipt.',
+        draftStorageUnavailable: 'Draft recovery storage unavailable',
+        draftEnabled: 'Draft recovery enabled',
+        checkStoredDrafts: 'Check stored drafts',
+        storeDraft: 'Store draft for recovery',
+        noStoredDrafts: 'No stored drafts',
+        moreStoredDrafts: 'More stored drafts exist than this listing shows.',
+        storedDraft: 'Stored draft',
+        draftConflict: 'Saved revision changed. Review this draft separately.',
+        draftMatches: 'Stored draft matches the checked saved revision.',
+        reviewStoredDraft: 'Review stored draft',
+        restoreDraft: 'Restore draft',
+        discardStoredDraft: 'Discard stored draft',
+        draftRestored: 'Draft restored locally. Save to publish it.',
+        draftDiscarded: 'Stored draft discarded. Current edits are unchanged.',
+        draftStorageFailed: 'Draft storage unavailable. Current edits are unchanged.',
+    },
+    fr: {
+        draftRecovery: 'Récupération de brouillon',
+        draftRecoveryState: kind => `Récupération de brouillon : ${frenchRecoveryStates[kind] ?? kind}`,
+        draftChecking: 'Recherche des brouillons enregistrés',
+        draftStoring: 'Enregistrement du brouillon',
+        draftStored: 'Brouillon conservé pour récupération. Ce n’est pas un enregistrement du document.',
+        draftStorageUnavailable: 'Stockage des brouillons indisponible',
+        draftEnabled: 'Récupération de brouillon activée',
+        checkStoredDrafts: 'Chercher les brouillons enregistrés',
+        storeDraft: 'Conserver le brouillon pour récupération',
+        noStoredDrafts: 'Aucun brouillon enregistré',
+        moreStoredDrafts: 'Il existe d’autres brouillons que ceux listés ici.',
+        storedDraft: 'Brouillon enregistré',
+        draftConflict: 'La version enregistrée a changé. Examinez ce brouillon à part.',
+        draftMatches: 'Ce brouillon correspond à la version enregistrée vérifiée.',
+        reviewStoredDraft: 'Examiner le brouillon',
+        restoreDraft: 'Restaurer le brouillon',
+        discardStoredDraft: 'Supprimer le brouillon',
+        draftRestored: 'Brouillon restauré localement. Enregistrez pour le publier.',
+        draftDiscarded: 'Brouillon supprimé. Vos modifications actuelles sont inchangées.',
+        draftStorageFailed: 'Stockage des brouillons indisponible. Vos modifications actuelles sont inchangées.',
+    },
+};

package/dist/voice-attempt.d.ts

@@ -0,0 +1,33 @@
+import type { VoiceCapture, VoiceRecording, VoiceStart } from './voice-capture.js';
+export type VoiceAttempt<Data, Phase extends string = never> = Data & {
+    readonly id: number;
+    readonly abort: AbortController;
+    readonly capture: VoiceCapture;
+    readonly maxMs: number;
+    phase: 'starting' | 'recording' | 'processing' | Phase;
+    seconds: number;
+    levels: readonly number[];
+    paused: boolean;
+    canPause: boolean;
+};
+export interface VoiceAttemptOptions<Data, Phase extends string> {
+    readonly valid?: (item: VoiceAttempt<Data, Phase>) => boolean;
+    readonly refused?: (result: Extract<VoiceStart, {
+        kind: 'refused';
+    }>) => void;
+}
+/** Owns only this viewer's microphone attempts, never the borrowed chat or native execution. */
+export declare function useVoiceAttempt<Data extends object, Phase extends string = never>(options?: VoiceAttemptOptions<Data, Phase>): {
+    attempts: readonly VoiceAttempt<Data, Phase>[];
+    captureSequence: number;
+    current: () => readonly VoiceAttempt<Data, Phase>[];
+    start: (data: Data, configuredMaxMs?: number) => VoiceAttempt<Data, Phase>;
+    stop: (item: VoiceAttempt<Data, Phase>) => Promise<VoiceRecording | null>;
+    pause: (item: VoiceAttempt<Data, Phase>) => void;
+    resume: (item: VoiceAttempt<Data, Phase>) => void;
+    remove: (item: VoiceAttempt<Data, Phase>) => void;
+    clear: () => void;
+    valid: (item: VoiceAttempt<Data, Phase>) => boolean;
+    update: () => void;
+};
+//# sourceMappingURL=voice-attempt.d.ts.map