phormat 0.0.5

package/dist/editor/model/calloutEditCommands.js

@@ -0,0 +1,305 @@
+import { paragraphBlockFromPlainText } from '../block-specs/paragraph/edit';
+import { deepCloneBlock, deepCloneBlocks, findBlockLocation, normalizeListOrdinalsForest } from './blockTree';
+import { inlineTextNode } from './inlineEditCommands';
+import { inlineNodesToPlainText } from './inlinePlain';
+import { findQuoteBlockPath, quoteEnterAtPlain } from './quoteEditCommands';
+import { listEnterAtPlain } from './listEditCommands';
+import { emptyParagraphBlockData } from './emptyParagraph';
+import { replaceSourceRange } from './blockEditCommands';
+const EMPTY_PARAGRAPH_AFTER = '\n\n \n\n';
+function syntheticRange() {
+    return { start: -1, end: -1, startLine: -1, endLine: -1, synthetic: true };
+}
+export function calloutBodySyntheticParagraphId(calloutId) {
+    return `callout-body-syn:${calloutId}`;
+}
+export function isCalloutBodySyntheticParagraphId(blockId) {
+    return blockId.startsWith('callout-body-syn:');
+}
+export function makeEmptyCalloutParagraph() {
+    return {
+        type: 'paragraph',
+        id: crypto.randomUUID(),
+        sourceRange: syntheticRange(),
+        data: emptyParagraphBlockData(0),
+        inlines: [],
+        children: []
+    };
+}
+export function makeCalloutBodySyntheticParagraph(calloutId) {
+    return {
+        type: 'paragraph',
+        id: calloutBodySyntheticParagraphId(calloutId),
+        sourceRange: syntheticRange(),
+        data: emptyParagraphBlockData(0),
+        inlines: [],
+        children: []
+    };
+}
+/** Write the first empty `> ` body line for an opener-only callout. */
+export function ensureCalloutEmptyBodyTransaction(source, doc, calloutBlockIndex) {
+    const block = doc.blocks[calloutBlockIndex];
+    if (!block || block.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    if ((block.children?.length ?? 0) > 0)
+        return { ok: false, error: 'Callout already has body.' };
+    const insertPos = block.sourceRange.end;
+    const insertion = '\n> ';
+    const newSource = replaceSourceRange(source, insertPos, insertPos, insertion);
+    const anchor = insertPos + 3;
+    return {
+        ok: true,
+        transaction: {
+            id: `callout-empty-body:${block.id}`,
+            operations: [{ type: 'replaceSlice', range: { start: insertPos, end: insertPos }, text: insertion }],
+            selection: { anchor, focus: anchor }
+        }
+    };
+}
+export function nodeAtCalloutPath(root, path) {
+    let n = root;
+    for (const i of path) {
+        const ch = n.children?.[i];
+        if (!ch)
+            return null;
+        n = ch;
+    }
+    return n;
+}
+/** Path from callout root to any descendant block id (excluding the callout root itself). */
+export function findCalloutDescendantPath(root, blockId) {
+    if (root.type !== 'callout')
+        return null;
+    function walk(node, prefix) {
+        for (let i = 0; i < (node.children?.length ?? 0); i++) {
+            const ch = node.children[i];
+            const p = [...prefix, i];
+            if (ch.id === blockId)
+                return p;
+            const nested = walk(ch, p);
+            if (nested)
+                return nested;
+        }
+        return null;
+    }
+    return walk(root, []);
+}
+export function calloutParagraphDisplayPlain(block) {
+    if (block.type !== 'paragraph')
+        return '';
+    if (block.inlines?.length)
+        return inlineNodesToPlainText(block.inlines);
+    return '';
+}
+function calloutSiblingContext(root, blockId) {
+    const path = findCalloutDescendantPath(root, blockId);
+    if (!path)
+        return null;
+    const node = nodeAtCalloutPath(root, path);
+    if (!node)
+        return null;
+    if (path.length === 0)
+        return null;
+    const parentPath = path.slice(0, -1);
+    const parent = parentPath.length === 0 ? root : nodeAtCalloutPath(root, parentPath);
+    if (!parent)
+        return null;
+    if (!parent.children)
+        parent.children = [];
+    const index = path[path.length - 1];
+    return { parent, siblings: parent.children, index, node };
+}
+export function calloutChildCanMoveSibling(root, blockId, direction) {
+    const ctx = calloutSiblingContext(root, blockId);
+    if (!ctx)
+        return false;
+    const newIdx = direction === 'up' ? ctx.index - 1 : ctx.index + 1;
+    return newIdx >= 0 && newIdx < ctx.siblings.length;
+}
+export function calloutMoveSibling(root, blockId, direction) {
+    const path = findCalloutDescendantPath(root, blockId);
+    if (!path)
+        return null;
+    const clone = deepCloneBlock(root);
+    const ctxRaw = calloutSiblingContext(clone, blockId);
+    if (!ctxRaw)
+        return null;
+    const idx = ctxRaw.index;
+    const newIdx = direction === 'up' ? idx - 1 : idx + 1;
+    if (newIdx < 0 || newIdx >= ctxRaw.siblings.length)
+        return null;
+    const kids = [...ctxRaw.siblings];
+    const [removed] = kids.splice(idx, 1);
+    if (!removed)
+        return null;
+    kids.splice(newIdx, 0, removed);
+    ctxRaw.parent.children = kids;
+    return clone;
+}
+export function calloutDeleteChild(root, blockId) {
+    const path = findCalloutDescendantPath(root, blockId);
+    if (!path)
+        return null;
+    const clone = deepCloneBlock(root);
+    const ctx = calloutSiblingContext(clone, blockId);
+    if (!ctx)
+        return null;
+    ctx.siblings.splice(ctx.index, 1);
+    return clone;
+}
+function reIdBlockTree(block) {
+    block.id = crypto.randomUUID();
+    for (const ch of block.children ?? [])
+        reIdBlockTree(ch);
+}
+export function calloutDuplicateChild(root, blockId) {
+    const path = findCalloutDescendantPath(root, blockId);
+    if (!path)
+        return null;
+    const clone = deepCloneBlock(root);
+    const ctx = calloutSiblingContext(clone, blockId);
+    if (!ctx)
+        return null;
+    const dup = deepCloneBlock(ctx.node);
+    reIdBlockTree(dup);
+    ctx.siblings.splice(ctx.index + 1, 0, dup);
+    return clone;
+}
+export function calloutSiblingIndexOffset(root, anchorId, focusId) {
+    const anchorPath = findCalloutDescendantPath(root, anchorId);
+    const focusPath = findCalloutDescendantPath(root, focusId);
+    if (!anchorPath || !focusPath || anchorPath.length !== focusPath.length)
+        return null;
+    for (let i = 0; i < anchorPath.length - 1; i++) {
+        if (anchorPath[i] !== focusPath[i])
+            return null;
+    }
+    return focusPath[focusPath.length - 1] - anchorPath[focusPath.length - 1];
+}
+export function siblingFocusIdForCalloutDelete(root, blockId) {
+    const ctx = calloutSiblingContext(root, blockId);
+    if (!ctx)
+        return undefined;
+    if (ctx.index > 0)
+        return ctx.siblings[ctx.index - 1]?.id;
+    if (ctx.index + 1 < ctx.siblings.length)
+        return ctx.siblings[ctx.index + 1]?.id;
+    return undefined;
+}
+function paragraphPlainEmpty(block) {
+    return calloutParagraphDisplayPlain(block).length === 0;
+}
+function shouldExitEmptyCalloutParagraph(ctx) {
+    if (!paragraphPlainEmpty(ctx.node))
+        return false;
+    if (ctx.index > 0) {
+        const prev = ctx.siblings[ctx.index - 1];
+        return prev?.type === 'paragraph' && paragraphPlainEmpty(prev);
+    }
+    return false;
+}
+export function calloutParagraphEnterAtPlain(root, blockId, offset, plainText) {
+    if (root.type !== 'callout')
+        return null;
+    const clone = deepCloneBlock(root);
+    const ctx = calloutSiblingContext(clone, blockId);
+    if (!ctx || ctx.node.type !== 'paragraph')
+        return null;
+    const body = plainText;
+    if (body.length === 0) {
+        if (shouldExitEmptyCalloutParagraph(ctx)) {
+            ctx.siblings.splice(ctx.index, 1);
+            return { root: clone, exitToParagraph: true };
+        }
+        const next = makeEmptyCalloutParagraph();
+        ctx.siblings.splice(ctx.index + 1, 0, next);
+        return { root: clone, focusBlockId: next.id };
+    }
+    if (offset <= 0) {
+        const next = makeEmptyCalloutParagraph();
+        ctx.siblings.splice(ctx.index, 0, next);
+        return { root: clone, focusBlockId: next.id };
+    }
+    if (offset >= body.length) {
+        const next = makeEmptyCalloutParagraph();
+        ctx.siblings.splice(ctx.index + 1, 0, next);
+        return { root: clone, focusBlockId: next.id };
+    }
+    const left = body.slice(0, offset);
+    const right = body.slice(offset);
+    ctx.node.inlines = left.length > 0 ? [inlineTextNode(left)] : [];
+    ctx.node.data = paragraphBlockFromPlainText(left, 0);
+    const next = makeEmptyCalloutParagraph();
+    next.inlines = right.length > 0 ? [inlineTextNode(right)] : [];
+    next.data = paragraphBlockFromPlainText(right, 0);
+    ctx.siblings.splice(ctx.index + 1, 0, next);
+    return { root: clone, focusBlockId: next.id };
+}
+export function calloutListItemEnterAtPlain(root, itemId, offset, plainText, source) {
+    if (root.type !== 'callout')
+        return null;
+    const clone = deepCloneBlock(root);
+    const blocks = [clone];
+    const result = listEnterAtPlain(blocks, itemId, offset, plainText, source);
+    if (!result)
+        return null;
+    if ('demoteToParagraph' in result && result.demoteToParagraph) {
+        return { root: blocks[0], focusBlockId: result.focusBlockId };
+    }
+    return { root: blocks[0], focusBlockId: result.focusBlockId };
+}
+function findBlockquoteRootInCallout(callout, blockId) {
+    function walk(node, prefix) {
+        if (node.type === 'blockquote' &&
+            (node.id === blockId || findQuoteBlockPath(node, blockId) !== null)) {
+            return { node, pathFromCallout: prefix };
+        }
+        for (let i = 0; i < (node.children?.length ?? 0); i++) {
+            const ch = node.children[i];
+            const found = walk(ch, [...prefix, i]);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    if (callout.type !== 'callout')
+        return null;
+    for (let i = 0; i < (callout.children?.length ?? 0); i++) {
+        const ch = callout.children[i];
+        const found = walk(ch, [i]);
+        if (found)
+            return found;
+    }
+    return null;
+}
+export function calloutBlockquoteEnterAtPlain(root, blockId, offset, plainText, source) {
+    if (root.type !== 'callout')
+        return null;
+    const clone = deepCloneBlock(root);
+    const hit = findBlockquoteRootInCallout(clone, blockId);
+    if (!hit)
+        return null;
+    const innerPath = findQuoteBlockPath(hit.node, blockId);
+    if (innerPath === null)
+        return null;
+    const result = quoteEnterAtPlain(hit.node, innerPath, offset, plainText, source);
+    if (!result)
+        return null;
+    if (result.exitToParagraph) {
+        // Replace blockquote with empty paragraph sibling in callout body
+        const ctx = calloutSiblingContext(clone, hit.node.id);
+        if (!ctx)
+            return null;
+        const para = makeEmptyCalloutParagraph();
+        ctx.siblings.splice(ctx.index, 1, para);
+        return { root: clone, focusBlockId: para.id };
+    }
+    // quoteEnterAtPlain mutates hit.node in place within clone
+    return { root: clone, focusBlockId: result.focusBlockId };
+}
+export function calloutExitReplacementMarkdown(calloutMd, caretInCallout) {
+    const replacement = calloutMd + EMPTY_PARAGRAPH_AFTER;
+    const caret = caretInCallout + calloutMd.length + 4;
+    return { replacement, caret };
+}
+export { EMPTY_PARAGRAPH_AFTER };

package/dist/editor/model/documentSelection.d.ts

@@ -0,0 +1,8 @@
+import type { EditorBlock } from './types';
+/** Walk the block tree and return the first node with `id`, or null. */
+export declare function findEditorBlockById(blocks: readonly EditorBlock[], id: string): EditorBlock | null;
+/**
+ * When a stored leaf id is missing after reparse, find the best fingerprint match in the new tree.
+ * Returns null when no candidate meets the reconcile score threshold.
+ */
+export declare function tryRemapDocumentSelectionBlockId(prevBlocks: readonly EditorBlock[], nextBlocks: readonly EditorBlock[], missingId: string): string | null;

package/dist/editor/model/documentSelection.js

@@ -0,0 +1,56 @@
+import { blockIdentityFingerprint } from './reconcileBlockIds';
+/** Walk the block tree and return the first node with `id`, or null. */
+export function findEditorBlockById(blocks, id) {
+    for (const block of blocks) {
+        if (block.id === id)
+            return block;
+        if (block.children?.length) {
+            const nested = findEditorBlockById(block.children, id);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+function prefixOverlap(a, b) {
+    let n = 0;
+    const max = Math.min(a.length, b.length);
+    while (n < max && a.charCodeAt(n) === b.charCodeAt(n))
+        n++;
+    return n;
+}
+const REMAP_MIN_SCORE = 55;
+function scoreRemapCandidate(prev, next) {
+    if (prev.type !== next.type)
+        return -1;
+    const fpPrev = blockIdentityFingerprint(prev);
+    const fpNext = blockIdentityFingerprint(next);
+    const pref = prefixOverlap(fpPrev, fpNext);
+    return pref + (fpPrev === fpNext ? 200 : 0);
+}
+function walkAllBlocks(blocks, visit) {
+    for (const block of blocks) {
+        visit(block);
+        if (block.children?.length)
+            walkAllBlocks(block.children, visit);
+    }
+}
+/**
+ * When a stored leaf id is missing after reparse, find the best fingerprint match in the new tree.
+ * Returns null when no candidate meets the reconcile score threshold.
+ */
+export function tryRemapDocumentSelectionBlockId(prevBlocks, nextBlocks, missingId) {
+    const prev = findEditorBlockById(prevBlocks, missingId);
+    if (!prev)
+        return null;
+    let bestId = null;
+    let bestScore = REMAP_MIN_SCORE - 1;
+    walkAllBlocks(nextBlocks, (next) => {
+        const score = scoreRemapCandidate(prev, next);
+        if (score > bestScore) {
+            bestScore = score;
+            bestId = next.id;
+        }
+    });
+    return bestScore >= REMAP_MIN_SCORE ? bestId : null;
+}

package/dist/editor/model/documentSelectionFromSource.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentSelection, EditorBlock, EditorSelection } from './types';
+/** Best-effort leaf {@link DocumentSelection} from a source-offset caret after reparse. */
+export declare function documentSelectionFromSourceOffset(blocks: readonly EditorBlock[], source: string, selection: EditorSelection): DocumentSelection | null;

package/dist/editor/model/documentSelectionFromSource.js

@@ -0,0 +1,45 @@
+import { headingBodySourceRange, headingDisplayPlain } from '../block-specs/heading/edit';
+import { paragraphDisplayPlain } from '../block-specs/paragraph';
+import { findEditorBlockById } from './documentSelection';
+import { findEditorBlockIdAtSourceOffset } from './findBlockAtSourceOffset';
+import { listItemDisplayPlain } from './listEditCommands';
+import { blockquoteBodyPlain } from './quoteEditCommands';
+import { normalizeSelectionRange } from './types';
+function plainOffsetInBlock(block, source, sourceOffset) {
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0)
+        return 0;
+    if (block.type === 'heading') {
+        const { start } = headingBodySourceRange(block, source);
+        const body = headingDisplayPlain(block);
+        return Math.max(0, Math.min(sourceOffset - start, body.length));
+    }
+    if (block.type === 'paragraph') {
+        const body = paragraphDisplayPlain(block);
+        const relative = sourceOffset - block.sourceRange.start;
+        return Math.max(0, Math.min(relative, body.length));
+    }
+    if (block.type === 'listItem') {
+        const body = listItemDisplayPlain(block, source);
+        const relative = sourceOffset - block.sourceRange.start;
+        return Math.max(0, Math.min(relative, body.length));
+    }
+    if (block.type === 'blockquote') {
+        const body = blockquoteBodyPlain(block, source);
+        const relative = sourceOffset - block.sourceRange.start;
+        return Math.max(0, Math.min(relative, body.length));
+    }
+    const relative = sourceOffset - block.sourceRange.start;
+    return Math.max(0, relative);
+}
+/** Best-effort leaf {@link DocumentSelection} from a source-offset caret after reparse. */
+export function documentSelectionFromSourceOffset(blocks, source, selection) {
+    const { start } = normalizeSelectionRange(selection);
+    const blockId = findEditorBlockIdAtSourceOffset(blocks, start);
+    if (!blockId)
+        return null;
+    const block = findEditorBlockById(blocks, blockId);
+    if (!block)
+        return null;
+    const plain = plainOffsetInBlock(block, source, start);
+    return { blockId, plain: { start: plain, end: plain } };
+}

package/dist/editor/model/documentToRenderBlocks.d.ts

@@ -0,0 +1,3 @@
+import type { AnyEditorRenderBlock } from '../plugins/types';
+import type { EditorBlock } from './types';
+export declare function documentBlocksToRenderBlocks(blocks: EditorBlock[]): AnyEditorRenderBlock[];

package/dist/editor/model/documentToRenderBlocks.js

@@ -0,0 +1,13 @@
+import { getBlockSpec } from '../block-specs/registry';
+export function documentBlocksToRenderBlocks(blocks) {
+    const out = [];
+    for (const b of blocks) {
+        const spec = getBlockSpec(b.type);
+        if (spec) {
+            out.push(spec.toRenderBlock(b));
+            continue;
+        }
+        console.error(`documentBlocksToRenderBlocks: missing BlockSpec for type "${b.type}"`);
+    }
+    return out;
+}

package/dist/editor/model/editorPipeline.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/editor/model/editorPipeline.bench.js

@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest';
+import { applyInlineSecondPass } from './inlineSecondPass';
+import { commitParagraphInlineDraft } from './inlineDraftCommit';
+import { tryIncrementalReparse } from './incrementalReparse';
+import { parseMarkdownDocument } from './parseMarkdownDocument';
+import { reconcileBlockIds } from './reconcileBlockIds';
+function paragraphs(n) {
+    return Array.from({ length: n }, (_, i) => `Paragraph ${i} with some body text.`).join('\n\n');
+}
+describe('editor pipeline bench', () => {
+    const md = paragraphs(500);
+    const parsed = applyInlineSecondPass(parseMarkdownDocument(md, null));
+    const blockIndex = 250;
+    const prevReal = parsed.blocks.filter((b) => !b.sourceRange.synthetic);
+    const commit = commitParagraphInlineDraft(md, parsed, blockIndex, parsed.blocks[blockIndex].inlines ?? [], 4);
+    if (!commit.ok)
+        throw new Error('commit setup failed');
+    bench('full reparse (~500 paragraphs)', () => {
+        const docParsed = applyInlineSecondPass(parseMarkdownDocument(md, null));
+        reconcileBlockIds(prevReal, docParsed.blocks);
+    });
+    bench('incremental paragraph commit (~500 paragraphs)', () => {
+        const result = tryIncrementalReparse(commit.source, null, parsed, blockIndex, 'paragraph');
+        if (!result.ok)
+            throw new Error(result.reason);
+    });
+});

package/dist/editor/model/editorTransactions.d.ts

@@ -0,0 +1,20 @@
+import type { EditorDocument, EditorTransaction, EditorSelection } from './types';
+export type TransactionBuildErr = {
+    ok: false;
+    error: string;
+};
+export type TransactionBuildOk = {
+    ok: true;
+    transaction: EditorTransaction;
+};
+export type TransactionBuildResult = TransactionBuildOk | TransactionBuildErr;
+/** Apply ordered slice replacements left-to-right on the current source string. */
+export declare function applyEditorTransaction(source: string, transaction: EditorTransaction): {
+    ok: true;
+    source: string;
+    selection: EditorSelection;
+};
+/** Proof path for the transaction foundation — structural delete as one replaceSlice op. */
+export declare function deleteBlockTransaction(source: string, doc: EditorDocument, blockIndex: number): TransactionBuildResult;
+/** Inserts a copy of the block markdown after it; caret at start of duplicate body. */
+export declare function duplicateBlockTransaction(source: string, doc: EditorDocument, blockIndex: number): TransactionBuildResult;

package/dist/editor/model/editorTransactions.js

@@ -0,0 +1,68 @@
+import { clampSelection } from './types';
+function replaceSourceSlice(source, start, end, replacement) {
+    return source.slice(0, start) + replacement + source.slice(end);
+}
+/** Apply ordered slice replacements left-to-right on the current source string. */
+export function applyEditorTransaction(source, transaction) {
+    let next = source;
+    for (const op of transaction.operations) {
+        next = applyEditorOperation(next, op);
+    }
+    return {
+        ok: true,
+        source: next,
+        selection: clampSelection(transaction.selection, next.length)
+    };
+}
+function applyEditorOperation(source, op) {
+    if (op.type === 'replaceSlice') {
+        return replaceSourceSlice(source, op.range.start, op.range.end, op.text);
+    }
+    throw new Error(`Unknown editor operation: ${op.type}`);
+}
+function assertEditableBlockIndex(doc, blockIndex, verb) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Invalid block index.' };
+    if (block.sourceRange.start < 0)
+        return { ok: false, error: `Cannot ${verb} synthetic block.` };
+    return { ok: true, block };
+}
+/** Proof path for the transaction foundation — structural delete as one replaceSlice op. */
+export function deleteBlockTransaction(source, doc, blockIndex) {
+    const checked = assertEditableBlockIndex(doc, blockIndex, 'delete');
+    if (!checked.ok)
+        return checked;
+    const block = checked.block;
+    const start = block.sourceRange.start;
+    const end = block.sourceRange.end;
+    const newSource = replaceSourceSlice(source, start, end, '');
+    const anchor = Math.min(start, newSource.length);
+    return {
+        ok: true,
+        transaction: {
+            id: `delete-block:${block.id}`,
+            operations: [{ type: 'replaceSlice', range: { start, end }, text: '' }],
+            selection: { anchor, focus: anchor }
+        }
+    };
+}
+/** Inserts a copy of the block markdown after it; caret at start of duplicate body. */
+export function duplicateBlockTransaction(source, doc, blockIndex) {
+    const checked = assertEditableBlockIndex(doc, blockIndex, 'duplicate');
+    if (!checked.ok)
+        return checked;
+    const block = checked.block;
+    const slice = source.slice(block.sourceRange.start, block.sourceRange.end);
+    const pos = block.sourceRange.end;
+    const insertion = `\n\n${slice}`;
+    const anchor = pos + 2;
+    return {
+        ok: true,
+        transaction: {
+            id: `duplicate-block:${block.id}`,
+            operations: [{ type: 'replaceSlice', range: { start: pos, end: pos }, text: insertion }],
+            selection: { anchor, focus: anchor }
+        }
+    };
+}

package/dist/editor/model/emptyParagraph.d.ts

@@ -0,0 +1,11 @@
+import type { ParagraphBlock } from '../block-specs/paragraph/types';
+import type { EditorBlock, EditorDocument } from './types';
+/** Canonical source body for a display-empty **paragraph** block. */
+export declare const EMPTY_PARAGRAPH_MARKER = " ";
+/** Typical top-level gap + empty body between sibling blocks. */
+export declare const EMPTY_PARAGRAPH_INSERTION = "\n\n \n\n";
+/** Normalize ingest / export for an empty document. */
+export declare function normalizeEmptySource(source: string): string;
+export declare function isDisplayEmptyParagraph(block: EditorBlock): boolean;
+export declare function isSoleEmptyParagraphDocument(doc: EditorDocument): boolean;
+export declare function emptyParagraphBlockData(startLineIndex?: number): ParagraphBlock;

package/dist/editor/model/emptyParagraph.js

@@ -0,0 +1,25 @@
+import { paragraphDisplayPlain } from '../block-specs/paragraph/edit';
+/** Canonical source body for a display-empty **paragraph** block. */
+export const EMPTY_PARAGRAPH_MARKER = ' ';
+/** Typical top-level gap + empty body between sibling blocks. */
+export const EMPTY_PARAGRAPH_INSERTION = '\n\n \n\n';
+/** Normalize ingest / export for an empty document. */
+export function normalizeEmptySource(source) {
+    return source === '' ? EMPTY_PARAGRAPH_MARKER : source;
+}
+export function isDisplayEmptyParagraph(block) {
+    if (block.type !== 'paragraph')
+        return false;
+    return paragraphDisplayPlain(block).trim() === '';
+}
+export function isSoleEmptyParagraphDocument(doc) {
+    return (doc.blocks.length === 1 &&
+        doc.blocks[0].type === 'paragraph' &&
+        isDisplayEmptyParagraph(doc.blocks[0]));
+}
+export function emptyParagraphBlockData(startLineIndex = 0) {
+    return {
+        startLineIndex,
+        lines: [{ text: EMPTY_PARAGRAPH_MARKER, softBreakAfter: false }]
+    };
+}

package/dist/editor/model/enterCommands.d.ts

@@ -0,0 +1,16 @@
+import type { EditorDocument, EditorTransaction } from './types';
+import type { FocusOutcome } from './focusOutcome';
+/** @deprecated Use {@link FocusOutcome} — same shape, enter-specific name retained for builders. */
+export type EnterFocusTarget = FocusOutcome;
+export type EnterCommandOutcome = {
+    ok: true;
+    kind: 'transaction';
+    transaction: EditorTransaction;
+    focus: EnterFocusTarget;
+    dirtyTopLevelIndex: number;
+} | {
+    ok: false;
+    error: string;
+};
+/** Build the outcome for {@link MarkdownEditor.enterAt} from block id and live plain snapshot. */
+export declare function buildEnterCommand(source: string, doc: EditorDocument, blockId: string, plainOffset: number, plainText: string): EnterCommandOutcome;