phormat 0.0.5

package/dist/editor/MarkdownEditor.svelte.js

@@ -0,0 +1,1119 @@
+import { applyInlineSecondPass, applyInlineWrap, applyStructuralMarkdownShortcut, applyEditorTransaction, clampSelection, convertHeadingLevel, convertHeadingToParagraph, convertParagraphToHeading, deleteBlockTransaction, documentBlocksToRenderBlocks, duplicateBlockTransaction, EDITOR_HISTORY_LIMIT, findEditorBlockById, findEditorBlockIdAtSourceOffset, mergeWithPreviousBlock, moveBlockDown, moveBlockToIndex as reorderBlockToIndexInDocument, moveBlockUp, parseMarkdownDocument, paragraphBlockToPlainText, paragraphDisplayPlain, reconcileBlockIds, replaceBlockMarkdownSlice, replaceSourceRange, FULL_REPARSE, tryIncrementalReparse, tryRemapDocumentSelectionBlockId, documentSelectionFromSourceOffset, updateBlockPlainText, applyListItemInlineWrapTransaction, applyQuoteParagraphInlineWrapTransaction, deleteListItemTransaction, deleteQuoteParagraphTransaction, duplicateListItemTransaction, duplicateQuoteParagraphTransaction, blockTreeDropTransaction, tabReparentBlockTransaction, listRegionStructMutation, moveListItemSiblingTransaction, moveQuoteParagraphSiblingTransaction, quoteParagraphReorderTransaction, quoteStructMutationTransaction, calloutDocumentStructMutation, deleteCalloutChildTransaction, duplicateCalloutChildTransaction, moveCalloutChildSiblingTransaction, siblingFocusIdForCalloutDelete, siblingFocusIdForListDelete, siblingFocusIdForQuoteDelete, buildEmptyParagraphInsertTransaction, insertEmptyParagraphRelative } from './model';
+import { isDisplayEmptyParagraph, isSoleEmptyParagraphDocument, normalizeEmptySource } from './model/emptyParagraph';
+import { sourceLineAndCharacterCount } from './model/line-utils';
+import { appendTableColumnInDocument, appendTableRowInDocument, commitTableCellInlineDraft, convertBlockToTable, navigateTableCellInDocument } from './block-specs/table/editCommands';
+import { buildEnterCommand } from './model/enterCommands';
+import { ensureCalloutEmptyBodyTransaction } from './model/calloutEditCommands';
+import { findListItemPath, resolveListItem, setListItemBodyPlain } from './model/listEditCommands';
+import { commitBlockquoteBodyInlineDraft, commitBlockquoteParagraphInlineDraft, commitCalloutListItemInlineDraft, commitCalloutOpenerDraft, commitCalloutParagraphInlineDraft, commitHeadingInlineDraft, commitParagraphInlineDraft } from './model/inlineDraftCommit';
+import { cloneInlineNodeDeep } from './model/inlineEditCommands';
+import { findBlockLocation, blockAtSiblingOffset } from './model/blockTree';
+import { serializeListItem } from './block-specs/list/serialize';
+import { SvelteSet } from 'svelte/reactivity';
+export class MarkdownEditor {
+    #source = $state('');
+    #fileName = $state(null);
+    #document = $state.raw({ source: '', fileName: null, blocks: [] });
+    #blocks = $state.raw([]);
+    #isLoading = $state(false);
+    #error = $state(null);
+    #selection = $state.raw({ anchor: 0, focus: 0 });
+    #lastSavedSource = $state('');
+    #undoStack = [];
+    #redoStack = [];
+    /** Block index being edited with coalesced undo; null when not in a plain-text session. */
+    #typingSessionBlockIndex = null;
+    /** Last plain selection inside a paragraph/heading surface (for inline commands). */
+    #inlinePlainFocus = null;
+    /** Leaf-block caret/range from editable surfaces that emit document selection. */
+    #documentSelection = $state.raw(null);
+    /** One-shot focus target after structural Enter/split; cleared once applied. */
+    #pendingFocusBlockId = $state.raw(null);
+    #pendingFocusTableCell = $state.raw(null);
+    #tableCellNavGuard = false;
+    /** Suppresses stale blur cleanup while a remounted surface restores focus. */
+    #pendingFocusBlurGuardId = null;
+    /** Suppress one plain-input commit on this block after Enter (browser may still insert a line break). */
+    #plainInputSuppressBlockId = null;
+    #reparseDepth = 0;
+    #sourceLineCount = $state(0);
+    #sourceCharacterCount = $state(0);
+    /** Top-level block ids edited this session; drives {@link serializeMarkdownDocumentPreserving}. */
+    #dirtyBlockIds = new SvelteSet();
+    #readonly = $state(false);
+    #suppressSourceNotify = false;
+    #sourceChangeListeners = new Set();
+    get source() {
+        return this.#source;
+    }
+    set source(value) {
+        this.#source = value;
+        this.#reparse(value, this.#fileName);
+    }
+    get fileName() {
+        return this.#fileName;
+    }
+    set fileName(value) {
+        this.#fileName = value;
+        this.#reparse(this.#source, value);
+    }
+    get document() {
+        return this.#document;
+    }
+    get blocks() {
+        return this.#blocks;
+    }
+    constructor() {
+        this.#applySourceAndSelection(normalizeEmptySource(''), { anchor: 0, focus: 0 });
+    }
+    get isLoading() {
+        return this.#isLoading;
+    }
+    get error() {
+        return this.#error;
+    }
+    get selection() {
+        return this.#selection;
+    }
+    get documentSelection() {
+        return this.#documentSelection;
+    }
+    get isReparsing() {
+        return this.#reparseDepth > 0;
+    }
+    /** Whether a post-structural focus restore is pending for this block (suppress stale blur cleanup). */
+    isPendingFocusTarget(blockId) {
+        return this.#pendingFocusBlurGuardId === blockId;
+    }
+    get sourceLineCount() {
+        return this.#sourceLineCount;
+    }
+    get sourceCharacterCount() {
+        return this.#sourceCharacterCount;
+    }
+    get dirty() {
+        return this.#source !== this.#lastSavedSource;
+    }
+    /** Stable ids of top-level blocks touched by edits (cleared on load, draft restore, undo/redo). Used with `serializeMarkdownDocumentPreserving`. */
+    get dirtyBlockIds() {
+        return new SvelteSet([...this.#dirtyBlockIds]);
+    }
+    isBlockDirty(id) {
+        return this.#dirtyBlockIds.has(id);
+    }
+    get readonly() {
+        return this.#readonly;
+    }
+    setReadonly(value) {
+        this.#readonly = value;
+    }
+    get canUndo() {
+        return this.#undoStack.length > 0;
+    }
+    get canRedo() {
+        return this.#redoStack.length > 0;
+    }
+    markSaved() {
+        this.#lastSavedSource = this.#source;
+    }
+    /** Replace document source — used by controlled embedders and demo file load. */
+    setSource(source, opts) {
+        const { fileName, resetHistory = true, syncBaseline = true, selection = { anchor: 0, focus: 0 } } = opts ?? {};
+        this.#error = null;
+        if (resetHistory) {
+            this.#undoStack = [];
+            this.#redoStack = [];
+            this.#typingSessionBlockIndex = null;
+            this.#dirtyBlockIds.clear();
+        }
+        if (fileName !== undefined) {
+            this.#fileName = fileName;
+        }
+        if (syncBaseline) {
+            this.#lastSavedSource = source;
+        }
+        this.#suppressSourceNotify = true;
+        try {
+            this.#applySourceAndSelection(normalizeEmptySource(source), selection);
+        }
+        finally {
+            this.#suppressSourceNotify = false;
+        }
+    }
+    /** Subscribe to source mutations (not fired during silent {@link setSource}). Returns unsubscribe. */
+    onSourceChange(listener) {
+        this.#sourceChangeListeners.add(listener);
+        return () => {
+            this.#sourceChangeListeners.delete(listener);
+        };
+    }
+    commitSourceEdit(result, dirtyBlockIndices, focusAfter) {
+        if (this.#readonly)
+            return false;
+        if (!result.ok) {
+            this.#error = result.error;
+            return false;
+        }
+        this.#error = null;
+        this.#undoStack.push(this.#captureHistorySnapshot());
+        if (this.#undoStack.length > EDITOR_HISTORY_LIMIT) {
+            this.#undoStack.shift();
+        }
+        this.#redoStack = [];
+        this.#typingSessionBlockIndex = null;
+        if (dirtyBlockIndices?.length) {
+            this.#markDirtyByBlockIndices(dirtyBlockIndices);
+        }
+        this.#applySourceAndSelection(result.source, result.selection, { focusAfter });
+        return true;
+    }
+    /** Apply a built transaction through the same undo/history path as {@link commitSourceEdit}. */
+    commitTransaction(transaction, dirtyBlockIndices, focusAfter) {
+        const applied = applyEditorTransaction(this.#source, transaction);
+        return this.commitSourceEdit(applied, dirtyBlockIndices, focusAfter);
+    }
+    undo() {
+        if (this.#readonly)
+            return false;
+        const snap = this.#undoStack.pop();
+        if (!snap)
+            return false;
+        this.#redoStack.push(this.#captureHistorySnapshot());
+        this.#error = null;
+        this.#typingSessionBlockIndex = null;
+        this.#dirtyBlockIds.clear();
+        this.#restoreHistorySnapshot(snap);
+        return true;
+    }
+    redo() {
+        if (this.#readonly)
+            return false;
+        const snap = this.#redoStack.pop();
+        if (!snap)
+            return false;
+        this.#undoStack.push(this.#captureHistorySnapshot());
+        this.#error = null;
+        this.#typingSessionBlockIndex = null;
+        this.#dirtyBlockIds.clear();
+        this.#restoreHistorySnapshot(snap);
+        return true;
+    }
+    /** One undo step per focused plain-text session (paragraph / heading body). */
+    beginPlainEditSession(blockIndex) {
+        if (this.#readonly)
+            return;
+        if (this.#typingSessionBlockIndex === blockIndex)
+            return;
+        this.#typingSessionBlockIndex = blockIndex;
+        this.#undoStack.push(this.#captureHistorySnapshot());
+        if (this.#undoStack.length > EDITOR_HISTORY_LIMIT) {
+            this.#undoStack.shift();
+        }
+        this.#redoStack = [];
+    }
+    commitPlainEditSession() {
+        this.#typingSessionBlockIndex = null;
+    }
+    silentUpdateBlockPlain(blockIndex, plainText, kind, selectionPlainOffset) {
+        const r = updateBlockPlainText(this.#source, this.#document, blockIndex, plainText, kind, selectionPlainOffset);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([blockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName);
+        this.#emitSourceChange();
+        return true;
+    }
+    commitParagraphInlineDraftAt(blockIndex, inlines, plainCaret) {
+        const r = commitParagraphInlineDraft(this.#source, this.#document, blockIndex, inlines, plainCaret);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([blockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName, {
+            kind: 'inlineDraftCommit',
+            blockIndex,
+            expectedType: 'paragraph'
+        });
+        this.#emitSourceChange();
+        return true;
+    }
+    commitHeadingInlineDraftAt(blockIndex, inlines, plainCaret) {
+        const r = commitHeadingInlineDraft(this.#source, this.#document, blockIndex, inlines, plainCaret);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([blockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName, {
+            kind: 'inlineDraftCommit',
+            blockIndex,
+            expectedType: 'heading'
+        });
+        this.#emitSourceChange();
+        return true;
+    }
+    commitTableCellInlineDraftAt(blockIndex, row, col, inlines, plainCaret) {
+        const block = this.#document.blocks[blockIndex];
+        const blockId = block?.id;
+        const r = commitTableCellInlineDraft(this.#source, this.#document, blockIndex, row, col, inlines, plainCaret);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([blockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        if (blockId) {
+            this.#documentSelection = {
+                blockId,
+                tableCell: { row, col },
+                plain: { start: plainCaret, end: plainCaret }
+            };
+        }
+        this.#reparse(r.source, this.#fileName, {
+            kind: 'inlineDraftCommit',
+            blockIndex,
+            expectedType: 'table'
+        });
+        this.#emitSourceChange();
+        return true;
+    }
+    navigateTableCellAt(blockIndex, from, to, inlines, plainCaret) {
+        const block = this.#document.blocks[blockIndex];
+        const blockId = block?.id;
+        this.#tableCellNavGuard = true;
+        this.commitPlainEditSession();
+        const r = navigateTableCellInDocument(this.#source, this.#document, blockIndex, from, to, inlines, plainCaret);
+        if (!r.ok) {
+            this.#tableCellNavGuard = false;
+            this.#error = r.error;
+            return false;
+        }
+        if (!('focusCell' in r) || !('focusPlain' in r))
+            return false;
+        const ok = this.commitSourceEdit(r, [blockIndex], blockId
+            ? {
+                mode: 'blockId',
+                blockId,
+                tableCell: r.focusCell,
+                plain: { start: r.focusPlain, end: r.focusPlain }
+            }
+            : undefined);
+        queueMicrotask(() => {
+            this.#tableCellNavGuard = false;
+        });
+        return ok;
+    }
+    appendTableRowAt(blockIndex) {
+        this.commitPlainEditSession();
+        const block = this.#document.blocks[blockIndex];
+        const blockId = block?.id;
+        const r = appendTableRowInDocument(this.#source, this.#document, blockIndex);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        if (!('focusCell' in r))
+            return false;
+        return this.commitSourceEdit(r, [blockIndex], blockId
+            ? {
+                mode: 'blockId',
+                blockId,
+                tableCell: r.focusCell,
+                plain: { start: 0, end: 0 }
+            }
+            : undefined);
+    }
+    appendTableColumnAt(blockIndex) {
+        this.commitPlainEditSession();
+        const block = this.#document.blocks[blockIndex];
+        const blockId = block?.id;
+        const r = appendTableColumnInDocument(this.#source, this.#document, blockIndex);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        if (!('focusCell' in r))
+            return false;
+        return this.commitSourceEdit(r, [blockIndex], blockId
+            ? {
+                mode: 'blockId',
+                blockId,
+                tableCell: r.focusCell,
+                plain: { start: 0, end: 0 }
+            }
+            : undefined);
+    }
+    convertBlockToTableAt(blockIndex) {
+        this.commitPlainEditSession();
+        const blockId = this.#document.blocks[blockIndex]?.id;
+        const r = convertBlockToTable(this.#source, this.#document, blockIndex);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        return this.commitSourceEdit(r, [blockIndex], blockId
+            ? {
+                mode: 'blockId',
+                blockId,
+                tableCell: { row: -1, col: 0 },
+                plain: { start: 0, end: 0 }
+            }
+            : undefined);
+    }
+    commitListItemInlineDraftAt(blockIndex, itemId, inlines, _plainCaret) {
+        void _plainCaret;
+        const loc = findBlockLocation(this.#document.blocks, itemId);
+        if (!loc || loc.block.type !== 'listItem')
+            return false;
+        loc.block.inlines = inlines.map(cloneInlineNodeDeep);
+        if (loc.parent === null) {
+            return this.silentReplaceBlockMarkdown(blockIndex, serializeListItem(loc.block, this.#source));
+        }
+        const top = this.#document.blocks[blockIndex];
+        if (top?.type === 'callout') {
+            return this.applyCalloutStructMutation(blockIndex, itemId, (blocks) => {
+                const inner = findBlockLocation(blocks, itemId);
+                if (!inner || inner.block.type !== 'listItem')
+                    return null;
+                inner.block.inlines = inlines.map(cloneInlineNodeDeep);
+                return blocks;
+            });
+        }
+        return this.applyListStructMutation(blockIndex, itemId, (blocks) => {
+            const inner = findBlockLocation(blocks, itemId);
+            if (!inner || inner.block.type !== 'listItem')
+                return null;
+            inner.block.inlines = inlines.map(cloneInlineNodeDeep);
+            return blocks;
+        });
+    }
+    commitBlockquoteBodyInlineDraftAt(topBlockIndex, quoteBlockId, inlines, _plainCaret) {
+        void _plainCaret;
+        const top = this.#document.blocks[topBlockIndex];
+        if (!top || top.type !== 'blockquote')
+            return false;
+        const r = commitBlockquoteBodyInlineDraft(this.#source, top, quoteBlockId, inlines);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([topBlockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName);
+        this.#emitSourceChange();
+        return true;
+    }
+    commitBlockquoteParagraphInlineDraftAt(topBlockIndex, paragraphId, inlines, _plainCaret) {
+        void _plainCaret;
+        const top = this.#document.blocks[topBlockIndex];
+        if (!top || top.type !== 'blockquote')
+            return false;
+        const r = commitBlockquoteParagraphInlineDraft(this.#source, top, paragraphId, inlines);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([topBlockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName);
+        this.#emitSourceChange();
+        return true;
+    }
+    commitCalloutOpenerDraftAt(topBlockIndex, calloutId, data) {
+        const top = this.#document.blocks[topBlockIndex];
+        if (!top || top.type !== 'callout')
+            return false;
+        const r = commitCalloutOpenerDraft(this.#source, top, calloutId, data);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([topBlockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName);
+        this.#emitSourceChange();
+        return true;
+    }
+    commitCalloutParagraphInlineDraftAt(topBlockIndex, paragraphId, inlines, _plainCaret) {
+        void _plainCaret;
+        const top = this.#document.blocks[topBlockIndex];
+        if (!top || top.type !== 'callout')
+            return false;
+        const r = commitCalloutParagraphInlineDraft(this.#source, top, paragraphId, inlines);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([topBlockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName);
+        this.#emitSourceChange();
+        return true;
+    }
+    commitCalloutListItemInlineDraftAt(topBlockIndex, itemId, inlines, _plainCaret) {
+        void _plainCaret;
+        const top = this.#document.blocks[topBlockIndex];
+        if (!top || top.type !== 'callout')
+            return false;
+        const r = commitCalloutListItemInlineDraft(this.#source, top, itemId, inlines);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([topBlockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName);
+        this.#emitSourceChange();
+        return true;
+    }
+    /** Ensure an imported opener-only callout has a real empty body line in source. */
+    ensureCalloutEmptyBodyAt(blockIndex) {
+        const top = this.#document.blocks[blockIndex];
+        if (!top || top.type !== 'callout')
+            return false;
+        if ((top.children?.length ?? 0) > 0)
+            return true;
+        const built = ensureCalloutEmptyBodyTransaction(this.#source, this.#document, blockIndex);
+        if (!built.ok)
+            return false;
+        return this.commitTransaction(built.transaction, [blockIndex], {
+            mode: 'sourceOffset',
+            offset: built.transaction.selection.anchor
+        });
+    }
+    updateBlockPlain(blockIndex, plainText, kind, selectionPlainOffset) {
+        return this.commitSourceEdit(updateBlockPlainText(this.#source, this.#document, blockIndex, plainText, kind, selectionPlainOffset), [blockIndex]);
+    }
+    /** @deprecated Use {@link tryStructuralMarkdownShortcut}. */
+    maybeApplyParagraphShortcut(blockIndex, plainText) {
+        this.tryStructuralMarkdownShortcut(blockIndex, plainText);
+    }
+    /** Sole public Enter API — dispatches by block type, commits via transactions, sets post-split focus. */
+    enterAt({ blockId, plainOffset, plainText }) {
+        this.commitPlainEditSession();
+        this.#plainInputSuppressBlockId = blockId;
+        const outcome = buildEnterCommand(this.#source, this.#document, blockId, plainOffset, plainText);
+        if (!outcome.ok) {
+            this.#plainInputSuppressBlockId = null;
+            this.#error = outcome.error;
+            return false;
+        }
+        this.#error = null;
+        const ok = this.commitTransaction(outcome.transaction, [outcome.dirtyTopLevelIndex], outcome.focus);
+        queueMicrotask(() => {
+            if (this.#plainInputSuppressBlockId === blockId) {
+                this.#plainInputSuppressBlockId = null;
+            }
+        });
+        return ok;
+    }
+    shouldSuppressPlainInputForBlock(blockId) {
+        return this.#plainInputSuppressBlockId === blockId;
+    }
+    shouldSkipTableCellBlurCommit() {
+        return this.#tableCellNavGuard;
+    }
+    /** Set post-command caret: resolves to {@link DocumentSelection} + one-shot pending focus. */
+    setFocusOutcome(target) {
+        this.#applyFocusOutcome(target);
+    }
+    mergeWithPrevious(blockIndex) {
+        const b = this.#document.blocks[blockIndex];
+        if (isSoleEmptyParagraphDocument(this.#document) &&
+            b?.type === 'paragraph' &&
+            isDisplayEmptyParagraph(b)) {
+            return true;
+        }
+        this.commitPlainEditSession();
+        const r = mergeWithPreviousBlock(this.#source, this.#document, blockIndex);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex - 1, blockIndex], r.focusAfter);
+    }
+    /** Line-start `#` / `-` / `1.` shortcut when the pattern is complete (Space, Enter, or blur). */
+    tryStructuralMarkdownShortcut(blockIndex, plainText) {
+        this.commitPlainEditSession();
+        const r = applyStructuralMarkdownShortcut(this.#source, this.#document, blockIndex, plainText);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex], r.focusAfter);
+    }
+    insertEmptyParagraph(blockIndex, after) {
+        this.commitPlainEditSession();
+        if (this.#document.blocks.length === 0) {
+            const edit = insertEmptyParagraphRelative(this.#source, this.#document, 0, after);
+            return this.commitSourceEdit(edit, []);
+        }
+        const edit = insertEmptyParagraphRelative(this.#source, this.#document, blockIndex, after);
+        return this.commitSourceEdit(edit, [blockIndex]);
+    }
+    deleteBlockAt(blockIndex) {
+        const b = this.#document.blocks[blockIndex];
+        if (isSoleEmptyParagraphDocument(this.#document) &&
+            b?.type === 'paragraph' &&
+            isDisplayEmptyParagraph(b)) {
+            return true;
+        }
+        this.commitPlainEditSession();
+        const built = deleteBlockTransaction(this.#source, this.#document, blockIndex);
+        if (!built.ok) {
+            this.#error = built.error;
+            return false;
+        }
+        return this.commitTransaction(built.transaction, [blockIndex]);
+    }
+    /** Replace one block’s source slice (code fences, lists, blockquotes). */
+    replaceBlockMarkdown(blockIndex, markdown) {
+        this.commitPlainEditSession();
+        const r = replaceBlockMarkdownSlice(this.#source, this.#document, blockIndex, markdown);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex]);
+    }
+    /** Coalesced list/blockquote/code edits within {@link beginPlainEditSession} (no undo frame per keystroke). */
+    silentReplaceBlockMarkdown(blockIndex, markdown) {
+        const r = replaceBlockMarkdownSlice(this.#source, this.#document, blockIndex, markdown);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#markDirtyByBlockIndices([blockIndex]);
+        this.#error = null;
+        this.#source = r.source;
+        this.#selection = clampSelection(r.selection, r.source.length);
+        this.#reparse(r.source, this.#fileName);
+        this.#emitSourceChange();
+        return true;
+    }
+    applyInlineWrapAt(blockIndex, plainStart, plainEnd, kind, linkHref) {
+        this.commitPlainEditSession();
+        const r = applyInlineWrap(this.#source, this.#document, blockIndex, plainStart, plainEnd, kind, linkHref);
+        if (!r.ok) {
+            this.#error = r.error;
+            return false;
+        }
+        this.#error = null;
+        return this.commitSourceEdit(r, [blockIndex]);
+    }
+    duplicateBlockAt(blockIndex) {
+        this.commitPlainEditSession();
+        const built = duplicateBlockTransaction(this.#source, this.#document, blockIndex);
+        if (!built.ok) {
+            this.#error = built.error;
+            return false;
+        }
+        this.#error = null;
+        return this.commitTransaction(built.transaction, [blockIndex]);
+    }
+    moveBlockUpAt(blockIndex) {
+        this.commitPlainEditSession();
+        const r = moveBlockUp(this.#source, this.#document, blockIndex);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex - 1, blockIndex]);
+    }
+    moveBlockDownAt(blockIndex) {
+        this.commitPlainEditSession();
+        const r = moveBlockDown(this.#source, this.#document, blockIndex);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex, blockIndex + 1]);
+    }
+    moveBlockToIndex(fromIndex, toIndex) {
+        this.commitPlainEditSession();
+        const lo = Math.min(fromIndex, toIndex);
+        const hi = Math.max(fromIndex, toIndex);
+        const affected = Array.from({ length: hi - lo + 1 }, (_, k) => lo + k);
+        const r = reorderBlockToIndexInDocument(this.#source, this.#document, fromIndex, toIndex);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, affected);
+    }
+    convertParagraphToHeadingAt(blockIndex, level) {
+        this.commitPlainEditSession();
+        const block = this.#document.blocks[blockIndex];
+        const r = convertParagraphToHeading(this.#source, this.#document, blockIndex, level);
+        if (!r.ok)
+            return false;
+        const plainLength = block?.type === 'paragraph'
+            ? paragraphBlockToPlainText(block.data).trimEnd().length
+            : 0;
+        return this.commitSourceEdit(r, [blockIndex], {
+            mode: 'sourceOffset',
+            offset: block?.sourceRange.start ?? 0,
+            plain: { start: plainLength, end: plainLength }
+        });
+    }
+    convertParagraphToBulletListAt(blockIndex) {
+        this.commitPlainEditSession();
+        const block = this.#document.blocks[blockIndex];
+        if (!block || block.type !== 'paragraph')
+            return false;
+        const plain = paragraphBlockToPlainText(block.data).trimEnd();
+        const markdown = `- ${plain}`;
+        const r = replaceBlockMarkdownSlice(this.#source, this.#document, blockIndex, markdown);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex], {
+            mode: 'sourceOffset',
+            offset: block.sourceRange.start,
+            plain: { start: plain.length, end: plain.length }
+        });
+    }
+    convertHeadingToParagraphAt(blockIndex) {
+        this.commitPlainEditSession();
+        const r = convertHeadingToParagraph(this.#source, this.#document, blockIndex);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex]);
+    }
+    convertHeadingLevelAt(blockIndex, level) {
+        this.commitPlainEditSession();
+        const r = convertHeadingLevel(this.#source, this.#document, blockIndex, level);
+        if (!r.ok)
+            return false;
+        return this.commitSourceEdit(r, [blockIndex]);
+    }
+    setSelection(sel) {
+        this.#selection = clampSelection(sel, this.#source.length);
+    }
+    setDocumentSelection(sel) {
+        this.#documentSelection = sel;
+    }
+    /**
+     * Caret/selection updates from a focused surface (selectionchange, keyup, input).
+     * Ignored while reparsing or another block owns {@link #pendingFocusBlockId}.
+     */
+    emitDocumentSelection(sel) {
+        if (this.#reparseDepth > 0)
+            return;
+        if (!this.#selectionAllowedForPending(sel))
+            return;
+        this.setDocumentSelection(sel);
+    }
+    /** Focus moved to this surface; ignored while reparsing or another block owns post-split focus. */
+    claimDocumentSelection(sel) {
+        if (this.#reparseDepth > 0)
+            return;
+        if (!this.#selectionAllowedForPending(sel))
+            return;
+        this.setDocumentSelection(sel);
+    }
+    /** Whether this block (and optional table cell) should receive one-shot programmatic focus. */
+    takePendingFocusForBlock(blockId, tableCell, surfaceBlockType) {
+        if (this.#pendingFocusBlockId !== blockId)
+            return false;
+        const pendingCell = this.#pendingFocusTableCell;
+        if (pendingCell) {
+            if (!tableCell || pendingCell.row !== tableCell.row || pendingCell.col !== tableCell.col) {
+                return false;
+            }
+        }
+        else if (tableCell) {
+            return false;
+        }
+        if (surfaceBlockType) {
+            const block = findEditorBlockById(this.#document.blocks, blockId);
+            if (!block || block.type !== surfaceBlockType)
+                return false;
+        }
+        this.#pendingFocusBlockId = null;
+        this.#pendingFocusTableCell = null;
+        return true;
+    }
+    clearDocumentSelection(blockId) {
+        if (this.#pendingFocusBlurGuardId === blockId)
+            return;
+        if (this.#documentSelection?.blockId === blockId) {
+            this.#documentSelection = null;
+        }
+    }
+    registerInlinePlainFocus(blockIndex, start, end) {
+        this.#inlinePlainFocus = { blockIndex, start, end };
+    }
+    clearInlinePlainFocus(blockIndex) {
+        if (this.#inlinePlainFocus?.blockIndex === blockIndex)
+            this.#inlinePlainFocus = null;
+    }
+    getInlinePlainFocus(blockIndex) {
+        const block = this.#document.blocks[blockIndex];
+        const docSel = this.#documentSelection;
+        if (block && docSel?.plain && docSel.blockId === block.id) {
+            return { start: docSel.plain.start, end: docSel.plain.end };
+        }
+        const f = this.#inlinePlainFocus;
+        if (!f || f.blockIndex !== blockIndex)
+            return null;
+        return { start: f.start, end: f.end };
+    }
+    getDocumentSelectionPlain(blockId) {
+        const sel = this.#documentSelection;
+        if (!sel || sel.blockId !== blockId || !sel.plain)
+            return null;
+        return { start: sel.plain.start, end: sel.plain.end };
+    }
+    #commitNestedStructural(built, blockIndex, opts = {}) {
+        if (!built.ok) {
+            this.#error = built.error;
+            return false;
+        }
+        const prevPlain = opts.preserveBlockId && this.#documentSelection?.blockId === opts.preserveBlockId
+            ? this.#documentSelection.plain
+            : undefined;
+        this.commitPlainEditSession();
+        this.#error = null;
+        const focusAfter = this.#focusOutcomeForNestedStructural(opts, prevPlain);
+        return this.commitTransaction(built.transaction, [blockIndex], focusAfter);
+    }
+    moveListItemSiblingAt(blockIndex, itemId, direction) {
+        return this.#commitNestedStructural(moveListItemSiblingTransaction(this.#source, this.#document, blockIndex, itemId, direction), blockIndex, { preserveBlockId: itemId });
+    }
+    blockTreeDropAt(draggedId, targetId, placement) {
+        const loc = findBlockLocation(this.#document.blocks, draggedId);
+        const blockIndex = loc?.topLevelIndex ?? 0;
+        return this.#commitNestedStructural(blockTreeDropTransaction(this.#source, this.#document, draggedId, targetId, placement), blockIndex, { preserveBlockId: draggedId });
+    }
+    applyBlockTreeTabReparent(blockId, shift, focusPlain) {
+        const loc = findBlockLocation(this.#document.blocks, blockId);
+        if (!loc)
+            return false;
+        const built = tabReparentBlockTransaction(this.#source, this.#document, blockId, shift);
+        if (!built.ok)
+            return false;
+        return this.#commitNestedStructural(built, loc.topLevelIndex, {
+            focusBlockId: blockId,
+            focusPlain: focusPlain ?? { start: 0, end: 0 }
+        });
+    }
+    listItemTreeDropAt(blockIndex, draggedId, targetId, placement) {
+        return this.blockTreeDropAt(draggedId, targetId, placement);
+    }
+    deleteListItemAt(blockIndex, itemId) {
+        const focusId = siblingFocusIdForListDelete(this.#document.blocks, itemId);
+        return this.#commitNestedStructural(deleteListItemTransaction(this.#source, this.#document, blockIndex, itemId, focusId), blockIndex, focusId ? { focusBlockId: focusId, focusPlain: { start: 0, end: 0 } } : {});
+    }
+    applyListStructMutation(blockIndex, itemId, mutate, opts) {
+        const caretBlockId = opts?.focusBlockId ?? opts?.preserveBlockId ?? itemId;
+        return this.#commitNestedStructural(listRegionStructMutation(this.#source, this.#document, itemId, mutate, `list-struct:${itemId}`, caretBlockId), blockIndex, opts?.focusBlockId
+            ? {
+                focusBlockId: opts.focusBlockId,
+                focusPlain: opts.focusPlain ?? { start: 0, end: 0 }
+            }
+            : { preserveBlockId: opts?.preserveBlockId ?? itemId });
+    }
+    applyQuoteStructMutation(blockIndex, quoteBlockId, mutate, opts) {
+        const caretBlockId = opts?.focusBlockId ?? quoteBlockId;
+        return this.#commitNestedStructural(quoteStructMutationTransaction(this.#source, this.#document, blockIndex, quoteBlockId, mutate, `quote-struct:${quoteBlockId}`, caretBlockId), blockIndex, opts?.focusBlockId
+            ? { focusBlockId: opts.focusBlockId, focusPlain: { start: 0, end: 0 } }
+            : { preserveBlockId: quoteBlockId });
+    }
+    updateListItemBodyAt(blockIndex, itemId, plain) {
+        const loc = findBlockLocation(this.#document.blocks, itemId);
+        if (!loc || loc.block.type !== 'listItem')
+            return false;
+        if (loc.parent === null) {
+            setListItemBodyPlain(loc.block, plain);
+            return this.silentReplaceBlockMarkdown(blockIndex, serializeListItem(loc.block, this.#source));
+        }
+        return this.applyListStructMutation(blockIndex, itemId, (blocks) => {
+            const inner = findBlockLocation(blocks, itemId);
+            if (!inner || inner.block.type !== 'listItem')
+                return null;
+            setListItemBodyPlain(inner.block, plain);
+            return blocks;
+        });
+    }
+    duplicateListItemAt(blockIndex, itemId) {
+        const built = duplicateListItemTransaction(this.#source, this.#document, blockIndex, itemId);
+        if (!built.ok) {
+            this.#error = built.error;
+            return false;
+        }
+        this.commitPlainEditSession();
+        this.#error = null;
+        const ok = this.commitTransaction(built.transaction, [blockIndex]);
+        if (!ok)
+            return false;
+        const path = findListItemPath(this.#document.blocks, itemId);
+        if (path) {
+            const nav = resolveListItem(this.#document.blocks, path);
+            const dup = nav?.siblings[nav.itemIndex + 1];
+            if (dup) {
+                this.setFocusOutcome({ mode: 'blockId', blockId: dup.id });
+            }
+        }
+        return true;
+    }
+    moveQuoteParagraphSiblingAt(blockIndex, paragraphId, direction) {
+        return this.#commitNestedStructural(moveQuoteParagraphSiblingTransaction(this.#source, this.#document, blockIndex, paragraphId, direction), blockIndex, { preserveBlockId: paragraphId });
+    }
+    quoteParagraphReorderAt(blockIndex, quotePath, fromIndex, toIndex, paragraphId) {
+        return this.#commitNestedStructural(quoteParagraphReorderTransaction(this.#source, this.#document, blockIndex, quotePath, fromIndex, toIndex, paragraphId), blockIndex, { preserveBlockId: paragraphId });
+    }
+    deleteQuoteParagraphAt(blockIndex, paragraphId) {
+        const block = this.#document.blocks[blockIndex];
+        const focusId = block?.type === 'blockquote' ? siblingFocusIdForQuoteDelete(block, paragraphId) : undefined;
+        return this.#commitNestedStructural(deleteQuoteParagraphTransaction(this.#source, this.#document, blockIndex, paragraphId, focusId), blockIndex, focusId ? { focusBlockId: focusId, focusPlain: { start: 0, end: 0 } } : {});
+    }
+    duplicateQuoteParagraphAt(blockIndex, paragraphId) {
+        const built = duplicateQuoteParagraphTransaction(this.#source, this.#document, blockIndex, paragraphId);
+        if (!built.ok) {
+            this.#error = built.error;
+            return false;
+        }
+        this.commitPlainEditSession();
+        this.#error = null;
+        const ok = this.commitTransaction(built.transaction, [blockIndex]);
+        if (!ok)
+            return false;
+        return true;
+    }
+    moveCalloutChildSiblingAt(blockIndex, childId, direction) {
+        return this.#commitNestedStructural(moveCalloutChildSiblingTransaction(this.#source, this.#document, blockIndex, childId, direction), blockIndex, { preserveBlockId: childId });
+    }
+    calloutBodyTreeDropAt(blockIndex, draggedId, targetId, placement) {
+        return this.blockTreeDropAt(draggedId, targetId, placement);
+    }
+    deleteCalloutChildAt(blockIndex, childId) {
+        const block = this.#document.blocks[blockIndex];
+        const focusId = block?.type === 'callout' ? siblingFocusIdForCalloutDelete(block, childId) : undefined;
+        return this.#commitNestedStructural(deleteCalloutChildTransaction(this.#source, this.#document, blockIndex, childId, focusId), blockIndex, focusId ? { focusBlockId: focusId, focusPlain: { start: 0, end: 0 } } : {});
+    }
+    duplicateCalloutChildAt(blockIndex, childId) {
+        const built = duplicateCalloutChildTransaction(this.#source, this.#document, blockIndex, childId);
+        if (!built.ok) {
+            this.#error = built.error;
+            return false;
+        }
+        this.commitPlainEditSession();
+        this.#error = null;
+        return this.commitTransaction(built.transaction, [blockIndex]);
+    }
+    applyCalloutStructMutation(blockIndex, anchorBlockId, mutate, opts) {
+        const caretBlockId = opts?.focusBlockId ?? opts?.preserveBlockId ?? anchorBlockId;
+        return this.#commitNestedStructural(calloutDocumentStructMutation(this.#source, this.#document, blockIndex, anchorBlockId, mutate, `callout-struct:${anchorBlockId}`, caretBlockId), blockIndex, opts?.focusBlockId
+            ? {
+                focusBlockId: opts.focusBlockId,
+                focusPlain: opts.focusPlain ?? { start: 0, end: 0 }
+            }
+            : { preserveBlockId: opts?.preserveBlockId ?? anchorBlockId });
+    }
+    applyInlineWrapOnNestedRow(blockIndex, rowBlockId, plainStart, plainEnd, kind, linkHref) {
+        this.commitPlainEditSession();
+        const block = this.#document.blocks[blockIndex];
+        if (!block)
+            return false;
+        const built = block.type === 'listItem'
+            ? applyListItemInlineWrapTransaction(this.#source, this.#document, blockIndex, rowBlockId, plainStart, plainEnd, kind, linkHref)
+            : block.type === 'blockquote'
+                ? applyQuoteParagraphInlineWrapTransaction(this.#source, this.#document, blockIndex, rowBlockId, plainStart, plainEnd, kind, linkHref)
+                : { ok: false, error: 'Unsupported container block.' };
+        return this.#commitNestedStructural(built, blockIndex, {
+            preserveBlockId: rowBlockId,
+            focusPlain: { start: plainEnd, end: plainEnd }
+        });
+    }
+    #captureHistorySnapshot() {
+        const docSel = this.#documentSelection;
+        return {
+            source: this.#source,
+            selection: { ...this.#selection },
+            documentSelection: docSel
+                ? {
+                    blockId: docSel.blockId,
+                    plain: docSel.plain ? { ...docSel.plain } : undefined,
+                    tableCell: docSel.tableCell ? { ...docSel.tableCell } : undefined
+                }
+                : null
+        };
+    }
+    #restoreHistorySnapshot(snap) {
+        const selection = clampSelection(snap.selection, snap.source.length);
+        const focusAfter = snap.documentSelection
+            ? {
+                mode: 'blockId',
+                blockId: snap.documentSelection.blockId,
+                plain: snap.documentSelection.plain ?? { start: 0, end: 0 },
+                tableCell: snap.documentSelection.tableCell
+            }
+            : undefined;
+        this.#applySourceAndSelection(snap.source, selection, { focusAfter });
+        if (snap.documentSelection)
+            return;
+        const derived = documentSelectionFromSourceOffset(this.#document.blocks, snap.source, selection);
+        if (derived) {
+            this.setFocusOutcome({
+                mode: 'blockId',
+                blockId: derived.blockId,
+                plain: derived.plain ?? { start: 0, end: 0 }
+            });
+        }
+    }
+    #focusOutcomeForNestedStructural(opts, prevPlain) {
+        if (opts.focusBlockId) {
+            return {
+                mode: 'blockId',
+                blockId: opts.focusBlockId,
+                plain: opts.focusPlain ?? { start: 0, end: 0 }
+            };
+        }
+        if (opts.preserveBlockId && findEditorBlockById(this.#document.blocks, opts.preserveBlockId)) {
+            const plain = opts.focusPlain ?? prevPlain;
+            if (plain) {
+                return { mode: 'blockId', blockId: opts.preserveBlockId, plain };
+            }
+        }
+        return undefined;
+    }
+    #armPostStructuralFocus(blockId, plain, tableCell) {
+        this.#documentSelection = { blockId, plain, tableCell };
+        this.#pendingFocusBlockId = blockId;
+        this.#pendingFocusTableCell = tableCell ?? null;
+        this.#pendingFocusBlurGuardId = blockId;
+        queueMicrotask(() => {
+            if (this.#pendingFocusBlurGuardId === blockId) {
+                this.#pendingFocusBlurGuardId = null;
+            }
+        });
+    }
+    #applyFocusOutcome(target) {
+        const plain = target.plain ?? { start: 0, end: 0 };
+        if (target.mode === 'blockId') {
+            this.#armPostStructuralFocus(target.blockId, plain, target.tableCell);
+            return;
+        }
+        if (target.mode === 'siblingOffset') {
+            const block = blockAtSiblingOffset(this.#document.blocks, target.anchorBlockId, target.offset);
+            if (block) {
+                this.#armPostStructuralFocus(block.id, plain);
+            }
+            return;
+        }
+        const targetId = findEditorBlockIdAtSourceOffset(this.#document.blocks, target.offset);
+        if (targetId) {
+            this.#armPostStructuralFocus(targetId, plain);
+        }
+    }
+    #emitSourceChange() {
+        if (this.#suppressSourceNotify)
+            return;
+        for (const listener of this.#sourceChangeListeners) {
+            listener(this.#source);
+        }
+    }
+    #applySourceAndSelection(source, selection, opts) {
+        const normalized = normalizeEmptySource(source);
+        this.#source = normalized;
+        this.#selection = clampSelection(selection, normalized.length);
+        if (opts?.focusAfter?.mode === 'blockId') {
+            this.#pendingFocusBlurGuardId = opts.focusAfter.blockId;
+        }
+        this.#reparse(normalized, this.#fileName);
+        if (opts?.focusAfter) {
+            this.#applyFocusOutcome(opts.focusAfter);
+        }
+        this.#emitSourceChange();
+    }
+    #reparse(source, fileName, opts = FULL_REPARSE) {
+        this.#reparseDepth++;
+        try {
+            const prevBlocks = this.#document.blocks;
+            const prevReal = prevBlocks.filter((b) => !b.sourceRange.synthetic);
+            let nextReal;
+            let docSource = normalizeEmptySource(source);
+            let docFileName = fileName;
+            if (opts.kind === 'inlineDraftCommit') {
+                const incremental = tryIncrementalReparse(docSource, fileName, this.#document, opts.blockIndex, opts.expectedType);
+                if (incremental.ok) {
+                    nextReal = incremental.document.blocks.filter((b) => !b.sourceRange.synthetic);
+                    docSource = normalizeEmptySource(incremental.document.source);
+                    docFileName = incremental.document.fileName;
+                }
+                else {
+                    const docParsed = applyInlineSecondPass(parseMarkdownDocument(docSource, fileName));
+                    nextReal = reconcileBlockIds(prevReal, docParsed.blocks);
+                }
+            }
+            else {
+                const docParsed = applyInlineSecondPass(parseMarkdownDocument(docSource, fileName));
+                nextReal = reconcileBlockIds(prevReal, docParsed.blocks);
+            }
+            this.#document = { source: docSource, fileName: docFileName, blocks: nextReal };
+            this.#blocks = documentBlocksToRenderBlocks(nextReal);
+            this.#pruneDirtyBlockIds(nextReal);
+            this.#restoreDocumentSelection(prevBlocks, nextReal);
+            const stats = sourceLineAndCharacterCount(docSource);
+            this.#sourceLineCount = stats.lineCount;
+            this.#sourceCharacterCount = stats.characterCount;
+        }
+        finally {
+            this.#reparseDepth--;
+        }
+    }
+    #restoreDocumentSelection(prevBlocks, nextBlocks) {
+        const sel = this.#documentSelection;
+        if (!sel)
+            return;
+        if (findEditorBlockById(nextBlocks, sel.blockId))
+            return;
+        const remapped = tryRemapDocumentSelectionBlockId(prevBlocks, nextBlocks, sel.blockId);
+        if (remapped) {
+            this.#documentSelection = { ...sel, blockId: remapped };
+        }
+        else {
+            this.#documentSelection = null;
+        }
+    }
+    #selectionAllowedForPending(sel) {
+        if (!this.#pendingFocusBlockId)
+            return true;
+        if (this.#pendingFocusBlockId !== sel.blockId)
+            return false;
+        const pendingCell = this.#pendingFocusTableCell;
+        if (!pendingCell)
+            return true;
+        if (!sel.tableCell)
+            return false;
+        return pendingCell.row === sel.tableCell.row && pendingCell.col === sel.tableCell.col;
+    }
+    #markDirtyByBlockIndices(indices) {
+        const blocks = this.#document.blocks;
+        for (const i of indices) {
+            const b = blocks[i];
+            if (b && b.sourceRange.start >= 0 && !b.sourceRange.synthetic) {
+                this.#dirtyBlockIds.add(b.id);
+            }
+        }
+    }
+    #pruneDirtyBlockIds(merged) {
+        const valid = new SvelteSet(merged.map((b) => b.id));
+        for (const id of this.#dirtyBlockIds) {
+            if (!valid.has(id))
+                this.#dirtyBlockIds.delete(id);
+        }
+    }
+}