phormat 0.0.5

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

@@ -0,0 +1,39 @@
+import type { EditorBlock } from './types';
+/** Child indices from a blockquote node downward (not including the top-level block index). */
+export type QuotePath = readonly number[];
+export declare function blockquoteDisplayPlain(block: EditorBlock, source: string): string;
+/** @deprecated Use {@link blockquoteDisplayPlain} — same plain text the edit surface shows. */
+export declare function blockquoteBodyPlain(block: EditorBlock, source: string): string;
+export declare function setBlockquoteBodyPlain(block: EditorBlock, plain: string): void;
+export declare function nodeAtQuotePath(root: EditorBlock, path: QuotePath): EditorBlock | null;
+export declare function findQuoteBlockPath(root: EditorBlock, blockId: string): QuotePath | null;
+/** Relative child index from `anchorId` to `focusId` under the same blockquote parent. */
+export declare function quoteSiblingIndexOffset(root: EditorBlock, anchorId: string, focusId: string): number | null;
+export declare function blockquoteAtSiblingOffset(root: EditorBlock, anchorId: string, offset: number): EditorBlock | null;
+/** @deprecated Use {@link findQuoteBlockPath}. */
+export declare function findQuoteParagraphPath(root: EditorBlock, paragraphId: string): QuotePath | null;
+export declare function quoteMoveSibling(root: EditorBlock, path: QuotePath, direction: 'up' | 'down'): EditorBlock | null;
+export declare function quoteDeleteBlock(root: EditorBlock, path: QuotePath): EditorBlock | null;
+export declare function quoteDuplicateBlock(root: EditorBlock, path: QuotePath): EditorBlock | null;
+export declare function quoteBlockCanMoveSibling(root: EditorBlock, path: QuotePath, direction: 'up' | 'down'): boolean;
+/** @deprecated */
+export declare function quoteDeleteParagraph(root: EditorBlock, path: QuotePath): EditorBlock | null;
+/** @deprecated */
+export declare function quoteDuplicateParagraph(root: EditorBlock, path: QuotePath): EditorBlock | null;
+/** @deprecated */
+export declare function quoteParagraphCanMoveSibling(root: EditorBlock, path: QuotePath, direction: 'up' | 'down'): boolean;
+/** @deprecated */
+export declare function quoteReorderParagraph(root: EditorBlock, quotePath: QuotePath, fromIndex: number, toIndex: number): EditorBlock | null;
+export declare function quoteBlockIndices(quote: EditorBlock): number[];
+export type QuoteEnterResult = {
+    root: EditorBlock;
+    focusBlockId: string;
+    exitToParagraph?: false;
+};
+export type QuoteExitResult = {
+    root: EditorBlock;
+    exitToParagraph: true;
+};
+export declare function quoteEnterAtPlain(root: EditorBlock, quotePath: QuotePath, offset: number, plainText: string, source: string): QuoteEnterResult | QuoteExitResult | null;
+/** @deprecated */
+export declare function quoteParagraphIndices(quote: EditorBlock): number[];

package/dist/editor/model/quoteEditCommands.js

@@ -0,0 +1,323 @@
+import { cloneInlineNodeDeep, inlineTextNode } from './inlineEditCommands';
+import { deepCloneBlock } from './blockTree';
+import { inlineNodesToPlainText } from './inlinePlain';
+function syntheticRange() {
+    return { start: -1, end: -1, startLine: -1, endLine: -1, synthetic: true };
+}
+export function blockquoteDisplayPlain(block, source) {
+    if (block.type !== 'blockquote')
+        return '';
+    if (block.inlines?.length)
+        return inlineNodesToPlainText(block.inlines);
+    if (block.sourceRange.start >= 0 && !block.sourceRange.synthetic) {
+        const slice = source.slice(block.sourceRange.start, block.sourceRange.end);
+        const firstLine = slice.split('\n')[0] ?? '';
+        const m = firstLine.match(/^\s*(?:>\s*)+(.*)$/);
+        return (m ? m[1] : firstLine).trimEnd();
+    }
+    return '';
+}
+/** @deprecated Use {@link blockquoteDisplayPlain} — same plain text the edit surface shows. */
+export function blockquoteBodyPlain(block, source) {
+    return blockquoteDisplayPlain(block, source);
+}
+export function setBlockquoteBodyPlain(block, plain) {
+    block.inlines = plain.length > 0 ? [inlineTextNode(plain)] : [];
+}
+export function nodeAtQuotePath(root, path) {
+    let n = root;
+    for (const i of path) {
+        const ch = n.children?.[i];
+        if (!ch)
+            return null;
+        n = ch;
+    }
+    return n;
+}
+export function findQuoteBlockPath(root, blockId) {
+    if (root.type === 'blockquote' && root.id === blockId)
+        return [];
+    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 && ch.type === 'blockquote')
+                return p;
+            if (ch.type === 'blockquote') {
+                const found = walk(ch, p);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    if (root.type !== 'blockquote')
+        return null;
+    return walk(root, []);
+}
+/** Relative child index from `anchorId` to `focusId` under the same blockquote parent. */
+export function quoteSiblingIndexOffset(root, anchorId, focusId) {
+    const anchorPath = findQuoteBlockPath(root, anchorId);
+    const focusPath = findQuoteBlockPath(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[anchorPath.length - 1];
+}
+export function blockquoteAtSiblingOffset(root, anchorId, offset) {
+    const anchorPath = findQuoteBlockPath(root, anchorId);
+    if (!anchorPath)
+        return null;
+    const parentPath = anchorPath.slice(0, -1);
+    const parent = parentPath.length === 0 ? root : nodeAtQuotePath(root, parentPath);
+    const idx = anchorPath[anchorPath.length - 1] + offset;
+    return parent?.children?.[idx] ?? null;
+}
+/** @deprecated Use {@link findQuoteBlockPath}. */
+export function findQuoteParagraphPath(root, paragraphId) {
+    return findQuoteBlockPath(root, paragraphId);
+}
+function parentAtPath(root, path) {
+    if (path.length === 0)
+        return root.type === 'blockquote' ? root : null;
+    const parentPath = path.slice(0, -1);
+    const parent = nodeAtQuotePath(root, parentPath);
+    return parent ?? root;
+}
+export function quoteMoveSibling(root, path, direction) {
+    if (path.length === 0)
+        return null;
+    const parent = parentAtPath(root, path);
+    const node = nodeAtQuotePath(root, path);
+    if (!parent || !node)
+        return null;
+    const idx = path[path.length - 1];
+    const newIdx = direction === 'up' ? idx - 1 : idx + 1;
+    const chs = parent.children ?? [];
+    if (newIdx < 0 || newIdx >= chs.length)
+        return null;
+    const clone = deepCloneBlock(root);
+    const liveParent = nodeAtQuotePath(clone, path.slice(0, -1));
+    if (!liveParent)
+        return null;
+    const kids = [...(liveParent.children ?? [])];
+    const [removed] = kids.splice(idx, 1);
+    if (!removed)
+        return null;
+    kids.splice(newIdx, 0, removed);
+    liveParent.children = kids;
+    return clone;
+}
+export function quoteDeleteBlock(root, path) {
+    const node = nodeAtQuotePath(root, path);
+    if (!node)
+        return null;
+    if (path.length === 0)
+        return null;
+    const clone = deepCloneBlock(root);
+    const parent = nodeAtQuotePath(clone, path.slice(0, -1));
+    if (!parent)
+        return null;
+    const idx = path[path.length - 1];
+    parent.children = (parent.children ?? []).filter((_, i) => i !== idx);
+    return clone;
+}
+export function quoteDuplicateBlock(root, path) {
+    const node = nodeAtQuotePath(root, path);
+    if (!node || node.type !== 'blockquote')
+        return null;
+    const clone = deepCloneBlock(root);
+    const parent = path.length === 0 ? null : nodeAtQuotePath(clone, path.slice(0, -1));
+    const src = nodeAtQuotePath(clone, path);
+    if (!src || src.type !== 'blockquote')
+        return null;
+    const dup = deepCloneBlock(src);
+    dup.id = crypto.randomUUID();
+    function reId(n) {
+        n.id = crypto.randomUUID();
+        for (const ch of n.children ?? [])
+            reId(ch);
+    }
+    reId(dup);
+    if (path.length === 0)
+        return dup;
+    if (!parent)
+        return null;
+    const idx = path[path.length - 1];
+    const kids = [...(parent.children ?? [])];
+    kids.splice(idx + 1, 0, dup);
+    parent.children = kids;
+    return clone;
+}
+export function quoteBlockCanMoveSibling(root, path, direction) {
+    if (path.length === 0)
+        return false;
+    const parent = parentAtPath(root, path);
+    const idx = path[path.length - 1];
+    const newIdx = direction === 'up' ? idx - 1 : idx + 1;
+    const chs = parent?.children ?? [];
+    return newIdx >= 0 && newIdx < chs.length;
+}
+/** @deprecated */
+export function quoteDeleteParagraph(root, path) {
+    return quoteDeleteBlock(root, path);
+}
+/** @deprecated */
+export function quoteDuplicateParagraph(root, path) {
+    return quoteDuplicateBlock(root, path);
+}
+/** @deprecated */
+export function quoteParagraphCanMoveSibling(root, path, direction) {
+    return quoteBlockCanMoveSibling(root, path, direction);
+}
+/** @deprecated */
+export function quoteReorderParagraph(root, quotePath, fromIndex, toIndex) {
+    const quote = nodeAtQuotePath(root, quotePath);
+    if (!quote || quote.type !== 'blockquote')
+        return null;
+    const chs = quote.children ?? [];
+    if (fromIndex === toIndex || fromIndex < 0 || toIndex < 0)
+        return null;
+    if (fromIndex >= chs.length || toIndex >= chs.length)
+        return null;
+    const clone = deepCloneBlock(root);
+    const liveQuote = nodeAtQuotePath(clone, quotePath);
+    if (!liveQuote)
+        return null;
+    const kids = [...(liveQuote.children ?? [])];
+    const [removed] = kids.splice(fromIndex, 1);
+    if (!removed)
+        return null;
+    kids.splice(toIndex, 0, removed);
+    liveQuote.children = kids;
+    return clone;
+}
+export function quoteBlockIndices(quote) {
+    const out = [];
+    const chs = quote.children ?? [];
+    for (let i = 0; i < chs.length; i++) {
+        if (chs[i]?.type === 'blockquote')
+            out.push(i);
+    }
+    return out;
+}
+function makeEmptyBlockquote() {
+    return {
+        type: 'blockquote',
+        id: crypto.randomUUID(),
+        sourceRange: syntheticRange(),
+        data: {},
+        children: [],
+        inlines: []
+    };
+}
+function quoteSiblingContext(root, path) {
+    const node = nodeAtQuotePath(root, path);
+    if (!node || node.type !== 'blockquote')
+        return null;
+    if (path.length === 0) {
+        if (!root.children)
+            root.children = [];
+        return { parent: root, siblings: root.children, index: -1, node: root, pathLength: 0 };
+    }
+    const parentPath = path.slice(0, -1);
+    const parent = nodeAtQuotePath(root, parentPath);
+    if (!parent)
+        return null;
+    if (!parent.children)
+        parent.children = [];
+    const index = path[path.length - 1];
+    return { parent, siblings: parent.children, index, node, pathLength: path.length };
+}
+function shouldExitEmptyQuote(ctx, source) {
+    const body = blockquoteDisplayPlain(ctx.node, source);
+    if (body.length > 0)
+        return false;
+    if (ctx.index > 0) {
+        const prev = ctx.siblings[ctx.index - 1];
+        return prev?.type === 'blockquote' && blockquoteBodyPlain(prev, source).length === 0;
+    }
+    if (ctx.index === 0 && ctx.pathLength > 0) {
+        return ctx.parent.type === 'blockquote' && blockquoteBodyPlain(ctx.parent, source).length === 0;
+    }
+    if (ctx.pathLength === 0) {
+        const kids = ctx.siblings;
+        const last = kids[kids.length - 1];
+        return last?.type === 'blockquote' && blockquoteBodyPlain(last, source).length === 0;
+    }
+    return false;
+}
+export function quoteEnterAtPlain(root, quotePath, offset, plainText, source) {
+    if (root.type !== 'blockquote')
+        return null;
+    const clone = deepCloneBlock(root);
+    const ctxRaw = quoteSiblingContext(clone, quotePath);
+    if (!ctxRaw)
+        return null;
+    const ctx = ctxRaw;
+    const body = plainText;
+    if (body.length === 0) {
+        if (shouldExitEmptyQuote(ctx, source)) {
+            if (ctx.pathLength === 0) {
+                setBlockquoteBodyPlain(ctx.node, '');
+                while (ctx.siblings.length > 0) {
+                    const last = ctx.siblings[ctx.siblings.length - 1];
+                    if (last?.type !== 'blockquote' || blockquoteBodyPlain(last, source).length > 0)
+                        break;
+                    ctx.siblings.pop();
+                }
+            }
+            else {
+                ctx.siblings.splice(ctx.index, 1);
+            }
+            return { root: clone, exitToParagraph: true };
+        }
+        const newQuote = makeEmptyBlockquote();
+        if (ctx.pathLength === 0) {
+            ctx.siblings.push(newQuote);
+        }
+        else {
+            ctx.siblings.splice(ctx.index + 1, 0, newQuote);
+        }
+        return { root: clone, focusBlockId: newQuote.id };
+    }
+    if (offset <= 0) {
+        const newQuote = makeEmptyBlockquote();
+        if (ctx.pathLength === 0) {
+            ctx.siblings.unshift(newQuote);
+        }
+        else {
+            ctx.siblings.splice(ctx.index, 0, newQuote);
+        }
+        return { root: clone, focusBlockId: newQuote.id };
+    }
+    if (offset >= body.length) {
+        const newQuote = makeEmptyBlockquote();
+        if (ctx.pathLength === 0) {
+            ctx.siblings.push(newQuote);
+        }
+        else {
+            ctx.siblings.splice(ctx.index + 1, 0, newQuote);
+        }
+        return { root: clone, focusBlockId: newQuote.id };
+    }
+    const left = body.slice(0, offset);
+    const right = body.slice(offset);
+    setBlockquoteBodyPlain(ctx.node, left);
+    const newQuote = makeEmptyBlockquote();
+    setBlockquoteBodyPlain(newQuote, right);
+    if (ctx.pathLength === 0) {
+        ctx.siblings.unshift(newQuote);
+    }
+    else {
+        ctx.siblings.splice(ctx.index + 1, 0, newQuote);
+    }
+    return { root: clone, focusBlockId: newQuote.id };
+}
+/** @deprecated */
+export function quoteParagraphIndices(quote) {
+    return quoteBlockIndices(quote);
+}

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

@@ -0,0 +1,9 @@
+import type { EditorBlock } from './types';
+/** Plain-text identity for matching block bodies. */
+export declare function blockIdentityFingerprint(block: EditorBlock): string;
+/**
+ * Reassigns stable session IDs to parsed blocks by matching the previous frame.
+ * Recurses into matched pairs' `children` so nested list items / blockquote children
+ * keep stable IDs across reparses. Synthetic blocks keep their existing `id` (editor-assigned).
+ */
+export declare function reconcileBlockIds(prev: EditorBlock[], next: EditorBlock[]): EditorBlock[];

package/dist/editor/model/reconcileBlockIds.js

@@ -0,0 +1,297 @@
+import { blockquoteReconcileFingerprint } from '../block-specs/blockquote/reconcile';
+import { calloutReconcileFingerprint } from '../block-specs/callout/reconcile';
+import { codeFenceReconcileFingerprint } from '../block-specs/codeFence/reconcile';
+import { columnsReconcileFingerprint } from '../block-specs/columns/reconcile';
+import { headingReconcileFingerprint } from '../block-specs/heading/reconcile';
+import { horizontalRuleReconcileFingerprint } from '../block-specs/horizontalRule/reconcile';
+import { listItemReconcileFingerprint } from '../block-specs/list/reconcile';
+import { paragraphReconcileFingerprint } from '../block-specs/paragraph/reconcile';
+import { tableReconcileFingerprint } from '../block-specs/table/reconcile';
+import { tocReconcileFingerprint } from '../block-specs/toc/reconcile';
+import { toggleReconcileFingerprint } from '../block-specs/toggle/reconcile';
+function newSessionId() {
+    return crypto.randomUUID();
+}
+/** Plain-text identity for matching block bodies. */
+export function blockIdentityFingerprint(block) {
+    if (block.type === 'paragraph') {
+        return paragraphReconcileFingerprint(block);
+    }
+    if (block.type === 'heading') {
+        return headingReconcileFingerprint(block);
+    }
+    if (block.type === 'listItem') {
+        return listItemReconcileFingerprint(block);
+    }
+    if (block.type === 'blockquote') {
+        return blockquoteReconcileFingerprint(block, blockIdentityFingerprint);
+    }
+    if (block.type === 'table') {
+        return tableReconcileFingerprint(block);
+    }
+    if (block.type === 'callout') {
+        return calloutReconcileFingerprint(block, blockIdentityFingerprint);
+    }
+    if (block.type === 'toggle') {
+        return toggleReconcileFingerprint(block);
+    }
+    if (block.type === 'codeFence') {
+        return codeFenceReconcileFingerprint(block);
+    }
+    if (block.type === 'horizontalRule') {
+        return horizontalRuleReconcileFingerprint(block);
+    }
+    if (block.type === 'columns') {
+        return columnsReconcileFingerprint(block);
+    }
+    if (block.type === 'toc') {
+        return tocReconcileFingerprint(block);
+    }
+    return `${block.type}:${block.sourceRange.startLine}:${block.sourceRange.endLine}`;
+}
+function realRange(block) {
+    return !block.sourceRange.synthetic && block.sourceRange.start >= 0;
+}
+/** Shared prefix length — cheap stand-in for similarity while typing. */
+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;
+}
+function scorePair(prev, next, prevIndex, nextIndex) {
+    if (prev.type !== next.type)
+        return -1;
+    const fpPrev = blockIdentityFingerprint(prev);
+    const fpNext = blockIdentityFingerprint(next);
+    const pref = prefixOverlap(fpPrev, fpNext);
+    const indexBonus = 50 - Math.min(50, Math.abs(prevIndex - nextIndex) * 5);
+    return pref + indexBonus + (fpPrev === fpNext ? 200 : 0);
+}
+function collectRealListItems(blocks) {
+    const out = [];
+    function walk(block) {
+        if (block.type === 'listItem' && realRange(block))
+            out.push(block);
+        for (const child of block.children ?? [])
+            walk(child);
+    }
+    for (const block of blocks)
+        walk(block);
+    return out;
+}
+function collectListItems(blocks) {
+    const out = [];
+    function walk(block) {
+        if (block.type === 'listItem')
+            out.push(block);
+        for (const child of block.children ?? [])
+            walk(child);
+    }
+    for (const block of blocks)
+        walk(block);
+    return out;
+}
+function collectAllIds(blocks) {
+    const out = new Set();
+    function walk(block) {
+        out.add(block.id);
+        for (const child of block.children ?? [])
+            walk(child);
+    }
+    for (const block of blocks)
+        walk(block);
+    return out;
+}
+/** Assign fresh UUIDs to every block in the subtree (used for unmatched / fresh nested children). */
+function assignFreshIdsRecursive(block) {
+    if (realRange(block)) {
+        block.id = newSessionId();
+    }
+    if (block.children) {
+        for (const c of block.children)
+            assignFreshIdsRecursive(c);
+    }
+}
+/**
+ * Reassigns stable session IDs to parsed blocks by matching the previous frame.
+ * Recurses into matched pairs' `children` so nested list items / blockquote children
+ * keep stable IDs across reparses. Synthetic blocks keep their existing `id` (editor-assigned).
+ */
+export function reconcileBlockIds(prev, next) {
+    const out = next.map((b) => cloneBlock(b));
+    const prevReal = prev.filter((p) => realRange(p));
+    const realNextIndices = [];
+    for (let i = 0; i < out.length; i++) {
+        if (realRange(out[i]))
+            realNextIndices.push(i);
+    }
+    if (realNextIndices.length === 0) {
+        return out;
+    }
+    if (prevReal.length === 0) {
+        for (const i of realNextIndices) {
+            assignFreshIdsRecursive(out[i]);
+        }
+        return out;
+    }
+    const usedPrev = new Set();
+    const matchedPrevByNextIdx = new Map();
+    // Phase 1: exact source start + type
+    for (const i of realNextIndices) {
+        const nb = out[i];
+        if (!realRange(nb))
+            continue;
+        for (let pj = 0; pj < prevReal.length; pj++) {
+            if (usedPrev.has(pj))
+                continue;
+            const pb = prevReal[pj];
+            if (pb.type !== nb.type)
+                continue;
+            if (pb.sourceRange.start !== nb.sourceRange.start)
+                continue;
+            out[i].id = pb.id;
+            usedPrev.add(pj);
+            matchedPrevByNextIdx.set(i, pb);
+            break;
+        }
+    }
+    // Phase 1b: empty list demotion preserves row identity across listItem -> paragraph.
+    for (const i of realNextIndices) {
+        if (matchedPrevByNextIdx.has(i))
+            continue;
+        const nb = out[i];
+        if (!realRange(nb) || nb.type !== 'paragraph')
+            continue;
+        for (let pj = 0; pj < prevReal.length; pj++) {
+            if (usedPrev.has(pj))
+                continue;
+            const pb = prevReal[pj];
+            if (pb.type !== 'listItem')
+                continue;
+            if (pb.sourceRange.start !== nb.sourceRange.start)
+                continue;
+            out[i].id = pb.id;
+            usedPrev.add(pj);
+            matchedPrevByNextIdx.set(i, pb);
+            break;
+        }
+    }
+    // Phase 1c: demotion that splits a list run shifts source offsets (blank lines
+    // inserted around the demoted row), so the exact-start match in Phase 1b misses.
+    // Empty-list demotion only fires on an empty body, and the demoted paragraph
+    // serializes with a whitespace placeholder, so match the nearest unmatched
+    // empty-bodied prev listItem to keep the row's reconciled id (post-split focus).
+    for (const i of realNextIndices) {
+        if (matchedPrevByNextIdx.has(i))
+            continue;
+        const nb = out[i];
+        if (!realRange(nb) || nb.type !== 'paragraph')
+            continue;
+        if (blockIdentityFingerprint(nb).trim().length > 0)
+            continue;
+        let bestPj = -1;
+        let bestDistance = Infinity;
+        for (let pj = 0; pj < prevReal.length; pj++) {
+            if (usedPrev.has(pj))
+                continue;
+            const pb = prevReal[pj];
+            if (pb.type !== 'listItem')
+                continue;
+            if (blockIdentityFingerprint(pb).trim().length > 0)
+                continue;
+            const distance = Math.abs(pb.sourceRange.start - nb.sourceRange.start);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                bestPj = pj;
+            }
+        }
+        if (bestPj >= 0) {
+            out[i].id = prevReal[bestPj].id;
+            usedPrev.add(bestPj);
+            matchedPrevByNextIdx.set(i, prevReal[bestPj]);
+        }
+    }
+    // Phase 2: greedy score
+    for (const i of realNextIndices) {
+        if (matchedPrevByNextIdx.has(i))
+            continue;
+        const nb = out[i];
+        let bestPj = -1;
+        let bestScore = -1;
+        for (let pj = 0; pj < prevReal.length; pj++) {
+            if (usedPrev.has(pj))
+                continue;
+            const origPrevIdx = prev.indexOf(prevReal[pj]);
+            const s = scorePair(prevReal[pj], nb, origPrevIdx, i);
+            if (s > bestScore) {
+                bestScore = s;
+                bestPj = pj;
+            }
+        }
+        if (bestPj >= 0 && bestScore >= 55) {
+            out[i].id = prevReal[bestPj].id;
+            usedPrev.add(bestPj);
+            matchedPrevByNextIdx.set(i, prevReal[bestPj]);
+        }
+    }
+    for (const i of realNextIndices) {
+        const nb = out[i];
+        const pb = matchedPrevByNextIdx.get(i);
+        if (!pb) {
+            assignFreshIdsRecursive(nb);
+            continue;
+        }
+        if (nb.children && nb.children.length > 0) {
+            const reconciledChildren = reconcileBlockIds(pb.children ?? [], nb.children);
+            nb.children = reconciledChildren;
+        }
+    }
+    reconcileMovedListItemIds(prev, out);
+    return out;
+}
+function reconcileMovedListItemIds(prev, next) {
+    const prevItems = collectRealListItems(prev);
+    if (prevItems.length === 0)
+        return;
+    const prevIds = new Set(prevItems.map((item) => item.id));
+    // A prev list-item id is off-limits if it is already carried by *any* next block,
+    // not just a next list item: empty-list demotion (Phase 1c) can assign a former
+    // list-item id to the demoted paragraph, and reusing it here would duplicate the key.
+    const usedPrevIds = new Set();
+    for (const id of collectAllIds(next)) {
+        if (prevIds.has(id))
+            usedPrevIds.add(id);
+    }
+    const nextItems = collectListItems(next);
+    for (let nextIndex = 0; nextIndex < nextItems.length; nextIndex++) {
+        const nextItem = nextItems[nextIndex];
+        if (prevIds.has(nextItem.id))
+            continue;
+        let best = null;
+        let bestScore = -1;
+        for (let prevIndex = 0; prevIndex < prevItems.length; prevIndex++) {
+            const prevItem = prevItems[prevIndex];
+            if (usedPrevIds.has(prevItem.id))
+                continue;
+            const score = scorePair(prevItem, nextItem, prevIndex, nextIndex);
+            if (score > bestScore) {
+                best = prevItem;
+                bestScore = score;
+            }
+        }
+        if (best && bestScore >= 55) {
+            nextItem.id = best.id;
+            usedPrevIds.add(best.id);
+        }
+    }
+}
+/** Shallow clone with a fresh `children` array (children themselves are reused; ids are mutated in place via `cloneBlock` recursion). */
+function cloneBlock(block) {
+    const out = { ...block };
+    if (block.children) {
+        out.children = block.children.map(cloneBlock);
+    }
+    return out;
+}

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

@@ -0,0 +1,12 @@
+import type { EditorBlockType } from './types';
+/** How {@link MarkdownEditor} chooses full vs incremental reparse. */
+export type ReparseKind = 'full' | 'inlineDraftCommit';
+export type InlineDraftCommitBlockType = Extract<EditorBlockType, 'paragraph' | 'heading' | 'table'>;
+export type ReparseOptions = {
+    kind: 'full';
+} | {
+    kind: 'inlineDraftCommit';
+    blockIndex: number;
+    expectedType: InlineDraftCommitBlockType;
+};
+export declare const FULL_REPARSE: ReparseOptions;

package/dist/editor/model/reparseOptions.js

@@ -0,0 +1 @@
+export const FULL_REPARSE = { kind: 'full' };

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

@@ -0,0 +1,6 @@
+import type { EditorBlock } from './types';
+/** Map live DOM plain + caret into model display-plain coordinates for Enter. */
+export declare function resolveEnterPlainSnapshot(block: EditorBlock, plainText: string, plainOffset: number, kind: 'paragraph' | 'heading'): {
+    plain: string;
+    offset: number;
+};