phormat 0.0.5

package/dist/editor/model/enterCommands.js

@@ -0,0 +1,288 @@
+import { normalizeBlockSliceReplacement } from './blockEditCommands';
+import { findBlockInDocument, siblingIndexOffset } from './blockTree';
+import { listEnterAtPlain } from './listEditCommands';
+import { findQuoteBlockPath, quoteEnterAtPlain, quoteSiblingIndexOffset } from './quoteEditCommands';
+import { serializeEditorBlock } from './serializeMarkdownDocument';
+import { listRegionStructMutation, quoteStructMutationTransaction, calloutStructMutationTransaction, calloutExitTransaction } from './nestedContainerTransactions';
+import { calloutBlockquoteEnterAtPlain, calloutListItemEnterAtPlain, calloutParagraphEnterAtPlain, calloutSiblingIndexOffset } from './calloutEditCommands';
+import { splitBlockAtPlainOffset, buildEmptyParagraphInsertTransaction } from './blockEditCommands';
+import { resolveEnterPlainSnapshot } from './resolveEnterPlainSnapshot';
+const EMPTY_PARAGRAPH_AFTER = '\n\n \n\n';
+function sliceReplaceTransaction(source, range, nextMarkdown, caret, txId) {
+    const text = normalizeBlockSliceReplacement(source, range.start, range.end, nextMarkdown);
+    return {
+        ok: true,
+        transaction: {
+            id: txId,
+            operations: [{ type: 'replaceSlice', range, text }],
+            selection: { anchor: caret, focus: caret }
+        }
+    };
+}
+function buildQuoteExitTransaction(source, doc, blockIndex, quoteBlockId, rootAfterExit) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'blockquote')
+        return { ok: false, error: 'Expected blockquote.' };
+    if (block.sourceRange.start < 0)
+        return { ok: false, error: 'Cannot edit synthetic block.' };
+    const quoteMd = serializeEditorBlock(rootAfterExit, source);
+    const replacement = quoteMd + EMPTY_PARAGRAPH_AFTER;
+    const caret = block.sourceRange.start + quoteMd.length + 4;
+    return sliceReplaceTransaction(source, { start: block.sourceRange.start, end: block.sourceRange.end }, replacement, caret, `quote-exit:${quoteBlockId}`);
+}
+function enterOutcomeFromTopLevelSplit(block, blockIndex, source, split, txId) {
+    if (!split.ok)
+        return split;
+    const rangeLen = block.sourceRange.end - block.sourceRange.start;
+    const replacement = split.source.slice(block.sourceRange.start, block.sourceRange.start + (split.source.length - source.length + rangeLen));
+    const built = sliceReplaceTransaction(source, { start: block.sourceRange.start, end: block.sourceRange.end }, replacement, split.selection.anchor, txId);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: { mode: 'siblingOffset', anchorBlockId: block.id, offset: 1 },
+        dirtyTopLevelIndex: blockIndex
+    };
+}
+function buildEmptyParagraphSiblingOutcome(source, doc, blockIndex, after, txId) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Invalid block index.' };
+    const built = buildEmptyParagraphInsertTransaction(source, doc, blockIndex, after, txId);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: after
+            ? { mode: 'siblingOffset', anchorBlockId: block.id, offset: 1 }
+            : { mode: 'blockId', blockId: block.id, plain: { start: 0, end: 0 } },
+        dirtyTopLevelIndex: blockIndex
+    };
+}
+function buildTopLevelBlockEnter(source, doc, blockIndex, plainOffset, plainText, kind) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Invalid block index.' };
+    if (block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not splittable.' };
+    }
+    const { plain: editPlain, offset: splitAt } = resolveEnterPlainSnapshot(block, plainText, plainOffset, kind);
+    if (kind === 'paragraph' && block.type === 'paragraph' && editPlain.trim() === '') {
+        return buildEmptyParagraphSiblingOutcome(source, doc, blockIndex, true, `paragraph-empty-enter:${block.id}`);
+    }
+    if (splitAt === 0) {
+        return buildEmptyParagraphSiblingOutcome(source, doc, blockIndex, false, `${kind}-enter-bol:${block.id}`);
+    }
+    if (splitAt >= editPlain.length) {
+        return buildEmptyParagraphSiblingOutcome(source, doc, blockIndex, true, `${kind}-enter-eol:${block.id}`);
+    }
+    if (kind === 'paragraph' && block.type === 'paragraph') {
+        const split = splitBlockAtPlainOffset(source, doc, blockIndex, splitAt, 'paragraph');
+        return enterOutcomeFromTopLevelSplit(block, blockIndex, source, split, `paragraph-enter:${block.id}`);
+    }
+    if (kind === 'heading' && block.type === 'heading') {
+        const split = splitBlockAtPlainOffset(source, doc, blockIndex, splitAt, 'heading');
+        return enterOutcomeFromTopLevelSplit(block, blockIndex, source, split, `heading-enter:${block.id}`);
+    }
+    return { ok: false, error: 'Split not supported for this block type.' };
+}
+function buildListItemEnter(source, doc, itemId, plainOffset, plainText) {
+    const loc = findBlockInDocument(doc, itemId);
+    if (!loc || loc.block.type !== 'listItem') {
+        return { ok: false, error: 'List item not found.' };
+    }
+    const result = listEnterAtPlain(doc.blocks, itemId, plainOffset, plainText, source);
+    if (!result)
+        return { ok: false, error: 'List enter failed.' };
+    if (result.demoteToParagraph) {
+        const built = listRegionStructMutation(source, doc, itemId, () => result.blocks, `list-demote:${itemId}`, result.focusBlockId);
+        if (!built.ok)
+            return built;
+        return {
+            ok: true,
+            kind: 'transaction',
+            transaction: built.transaction,
+            focus: {
+                mode: 'blockId',
+                blockId: result.focusBlockId,
+                plain: { start: 0, end: 0 }
+            },
+            dirtyTopLevelIndex: loc.topLevelIndex
+        };
+    }
+    const focusOffset = siblingIndexOffset(result.blocks, itemId, result.focusBlockId);
+    const built = listRegionStructMutation(source, doc, itemId, () => result.blocks, `list-enter:${itemId}`, result.focusBlockId);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: focusOffset !== null
+            ? { mode: 'siblingOffset', anchorBlockId: itemId, offset: focusOffset }
+            : { mode: 'blockId', blockId: result.focusBlockId },
+        dirtyTopLevelIndex: loc.topLevelIndex
+    };
+}
+function buildBlockquoteEnter(source, doc, blockId, plainOffset, plainText) {
+    const loc = findBlockInDocument(doc, blockId);
+    if (!loc || loc.block.type !== 'blockquote') {
+        return { ok: false, error: 'Blockquote node not found.' };
+    }
+    const root = doc.blocks[loc.topLevelIndex];
+    if (!root || root.type !== 'blockquote') {
+        return { ok: false, error: 'Expected top-level blockquote.' };
+    }
+    const quotePath = findQuoteBlockPath(root, blockId);
+    if (quotePath === null)
+        return { ok: false, error: 'Blockquote path not found.' };
+    const result = quoteEnterAtPlain(root, quotePath, plainOffset, plainText, source);
+    if (!result)
+        return { ok: false, error: 'Blockquote enter failed.' };
+    if (result.exitToParagraph) {
+        const built = buildQuoteExitTransaction(source, doc, loc.topLevelIndex, blockId, result.root);
+        if (!built.ok)
+            return built;
+        return {
+            ok: true,
+            kind: 'transaction',
+            transaction: built.transaction,
+            focus: { mode: 'sourceOffset', offset: built.transaction.selection.anchor },
+            dirtyTopLevelIndex: loc.topLevelIndex
+        };
+    }
+    const focusOffset = quoteSiblingIndexOffset(root, blockId, result.focusBlockId);
+    const built = quoteStructMutationTransaction(source, doc, loc.topLevelIndex, blockId, () => result.root, `quote-enter:${blockId}`, result.focusBlockId);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: focusOffset !== null
+            ? { mode: 'siblingOffset', anchorBlockId: blockId, offset: focusOffset }
+            : { mode: 'blockId', blockId: result.focusBlockId },
+        dirtyTopLevelIndex: loc.topLevelIndex
+    };
+}
+function buildCalloutExitTransaction(source, doc, blockIndex, rootAfterExit) {
+    const built = calloutExitTransaction(source, doc, blockIndex, rootAfterExit);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: { mode: 'sourceOffset', offset: built.transaction.selection.anchor },
+        dirtyTopLevelIndex: blockIndex
+    };
+}
+function buildCalloutParagraphEnter(source, doc, blockIndex, blockId, plainOffset, plainText) {
+    const root = doc.blocks[blockIndex];
+    if (!root || root.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    const result = calloutParagraphEnterAtPlain(root, blockId, plainOffset, plainText);
+    if (!result)
+        return { ok: false, error: 'Callout paragraph enter failed.' };
+    if (result.exitToParagraph) {
+        return buildCalloutExitTransaction(source, doc, blockIndex, result.root);
+    }
+    const focusOffset = calloutSiblingIndexOffset(root, blockId, result.focusBlockId);
+    const built = calloutStructMutationTransaction(source, doc, blockIndex, blockId, () => result.root, `callout-paragraph-enter:${blockId}`, result.focusBlockId);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: focusOffset !== null
+            ? { mode: 'siblingOffset', anchorBlockId: blockId, offset: focusOffset }
+            : { mode: 'blockId', blockId: result.focusBlockId },
+        dirtyTopLevelIndex: blockIndex
+    };
+}
+function buildCalloutListItemEnter(source, doc, blockIndex, itemId, plainOffset, plainText) {
+    const root = doc.blocks[blockIndex];
+    if (!root || root.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    const result = calloutListItemEnterAtPlain(root, itemId, plainOffset, plainText, source);
+    if (!result)
+        return { ok: false, error: 'Callout list enter failed.' };
+    if (result.exitToParagraph) {
+        return buildCalloutExitTransaction(source, doc, blockIndex, result.root);
+    }
+    const focusOffset = calloutSiblingIndexOffset(root, itemId, result.focusBlockId);
+    const built = calloutStructMutationTransaction(source, doc, blockIndex, itemId, () => result.root, `callout-list-enter:${itemId}`, result.focusBlockId);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: focusOffset !== null
+            ? { mode: 'siblingOffset', anchorBlockId: itemId, offset: focusOffset }
+            : { mode: 'blockId', blockId: result.focusBlockId },
+        dirtyTopLevelIndex: blockIndex
+    };
+}
+function buildCalloutBlockquoteEnter(source, doc, blockIndex, blockId, plainOffset, plainText) {
+    const root = doc.blocks[blockIndex];
+    if (!root || root.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    const result = calloutBlockquoteEnterAtPlain(root, blockId, plainOffset, plainText, source);
+    if (!result)
+        return { ok: false, error: 'Callout blockquote enter failed.' };
+    if (result.exitToParagraph) {
+        return buildCalloutExitTransaction(source, doc, blockIndex, result.root);
+    }
+    const built = calloutStructMutationTransaction(source, doc, blockIndex, blockId, () => result.root, `callout-quote-enter:${blockId}`, result.focusBlockId);
+    if (!built.ok)
+        return built;
+    return {
+        ok: true,
+        kind: 'transaction',
+        transaction: built.transaction,
+        focus: { mode: 'blockId', blockId: result.focusBlockId },
+        dirtyTopLevelIndex: blockIndex
+    };
+}
+function buildCalloutChildEnter(source, doc, loc, blockId, plainOffset, plainText) {
+    switch (loc.block.type) {
+        case 'paragraph':
+            return buildCalloutParagraphEnter(source, doc, loc.topLevelIndex, blockId, plainOffset, plainText);
+        case 'listItem':
+            return buildCalloutListItemEnter(source, doc, loc.topLevelIndex, blockId, plainOffset, plainText);
+        case 'blockquote':
+            return buildCalloutBlockquoteEnter(source, doc, loc.topLevelIndex, blockId, plainOffset, plainText);
+        default:
+            return { ok: false, error: 'Enter not supported for this callout child type.' };
+    }
+}
+/** Build the outcome for {@link MarkdownEditor.enterAt} from block id and live plain snapshot. */
+export function buildEnterCommand(source, doc, blockId, plainOffset, plainText) {
+    const loc = findBlockInDocument(doc, blockId);
+    if (!loc)
+        return { ok: false, error: 'Block not found.' };
+    const topBlock = doc.blocks[loc.topLevelIndex];
+    if (topBlock?.type === 'callout' && loc.parent !== null) {
+        return buildCalloutChildEnter(source, doc, loc, blockId, plainOffset, plainText);
+    }
+    switch (loc.block.type) {
+        case 'paragraph':
+            if (loc.parent !== null)
+                return { ok: false, error: 'Nested paragraph enter not supported.' };
+            return buildTopLevelBlockEnter(source, doc, loc.topLevelIndex, plainOffset, plainText, 'paragraph');
+        case 'heading':
+            return buildTopLevelBlockEnter(source, doc, loc.topLevelIndex, plainOffset, plainText, 'heading');
+        case 'listItem':
+            return buildListItemEnter(source, doc, blockId, plainOffset, plainText);
+        case 'blockquote':
+            return buildBlockquoteEnter(source, doc, blockId, plainOffset, plainText);
+        default:
+            return { ok: false, error: 'Enter not supported for this block type.' };
+    }
+}

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

@@ -0,0 +1,29 @@
+import { type LinkRefDefinition } from '../plugins/links-images/parse-links-images';
+/** Lines inside closed fenced code blocks (inclusive). */
+export declare function fenceCoveredLineIndices(openClosePairs: {
+    openLine: number;
+    closeLine: number;
+}[]): Set<number>;
+/** `[label][ref]` where the reference cannot be resolved (non-blocking). */
+export declare function collectUnresolvedReferenceLinkWarnings(source: string, codeFenceRanges?: {
+    start: number;
+    end: number;
+}[]): string[];
+/** `![alt|bad](url)` where the format suffix does not match grammar (non-blocking). */
+export declare function collectMalformedImageSuffixWarnings(source: string, codeFenceRanges?: {
+    start: number;
+    end: number;
+}[]): string[];
+/**
+ * Non-blocking notices for extension syntax that is not modeled in the editor tree,
+ * plus unresolved reference links. Narrowed automatically for features handled by
+ * `parseMarkdownDocument` (tables, callouts, toggles, columns, `::toc`, task lists).
+ */
+export declare function collectExtensionSyntaxWarnings(source: string, fencePairs: {
+    openLine: number;
+    closeLine: number;
+}[], fenceCharRanges?: {
+    start: number;
+    end: number;
+}[]): string[];
+export type { LinkRefDefinition };

package/dist/editor/model/extensionSyntaxWarnings.js

@@ -0,0 +1,122 @@
+import { collectDefinitionsAndExcluded, normalizeLinkLabel, parseBracketedContent, parseLinksImages } from '../plugins/links-images/parse-links-images';
+import { afterBracketLabelContent, parseImageLabelLayout } from '../plugins/links-images/parse-image-layout';
+import { splitLinesWithOffsets } from './line-utils';
+/** Lines inside closed fenced code blocks (inclusive). */
+export function fenceCoveredLineIndices(openClosePairs) {
+    const set = new Set();
+    for (const p of openClosePairs) {
+        for (let ln = p.openLine; ln <= p.closeLine; ln++)
+            set.add(ln);
+    }
+    return set;
+}
+function lineInsideFence(line, fenceLines) {
+    return fenceLines.has(line);
+}
+/** `[label][ref]` where the reference cannot be resolved (non-blocking). */
+export function collectUnresolvedReferenceLinkWarnings(source, codeFenceRanges = []) {
+    const { defs, excluded } = collectDefinitionsAndExcluded(source);
+    const warns = [];
+    function skipOffset(i) {
+        if (excluded.some((r) => i >= r.start && i < r.end))
+            return true;
+        return codeFenceRanges.some((r) => i >= r.start && i < r.end);
+    }
+    let i = 0;
+    while (i < source.length) {
+        if (skipOffset(i)) {
+            i++;
+            continue;
+        }
+        if (source[i] !== '[') {
+            i++;
+            continue;
+        }
+        const labelParsed = parseBracketedContent(source, i + 1);
+        if (!labelParsed) {
+            i++;
+            continue;
+        }
+        const after = labelParsed.end;
+        let k = after;
+        while (k < source.length &&
+            (source[k] === ' ' || source[k] === '\t' || source[k] === '\n' || source[k] === '\r')) {
+            k++;
+        }
+        if (source[k] !== '[') {
+            i++;
+            continue;
+        }
+        const refParsed = parseBracketedContent(source, k + 1);
+        if (!refParsed) {
+            i++;
+            continue;
+        }
+        const refKeyRaw = refParsed.content.trim();
+        const refKey = refKeyRaw
+            ? normalizeLinkLabel(refKeyRaw)
+            : normalizeLinkLabel(labelParsed.content);
+        const def = defs.get(refKey);
+        if (!def) {
+            const line = source.slice(0, i).split('\n').length;
+            warns.push(`Unresolved reference link at line ${line}: [${labelParsed.content}][${refKeyRaw || ''}]`);
+        }
+        i = refParsed.end;
+    }
+    return warns;
+}
+function isInlineParenImage(source, start, _labelLength, end) {
+    void _labelLength;
+    const labelStart = start + 2;
+    const afterLabel = afterBracketLabelContent(source, labelStart);
+    if (afterLabel === null)
+        return false;
+    let k = afterLabel;
+    while (k < end && (source[k] === ' ' || source[k] === '\t' || source[k] === '\n' || source[k] === '\r')) {
+        k++;
+    }
+    return k < end && source[k] === '(';
+}
+/** `![alt|bad](url)` where the format suffix does not match grammar (non-blocking). */
+export function collectMalformedImageSuffixWarnings(source, codeFenceRanges = []) {
+    const warns = [];
+    function inFence(i) {
+        return codeFenceRanges.some((r) => i >= r.start && i < r.end);
+    }
+    for (const block of parseLinksImages(source)) {
+        if (block.kind !== 'image')
+            continue;
+        if (inFence(block.start))
+            continue;
+        if (!isInlineParenImage(source, block.start, block.label.length, block.end))
+            continue;
+        const layout = parseImageLabelLayout(block.label);
+        if (!layout.malformedSuffix)
+            continue;
+        const line = source.slice(0, block.start).split('\n').length;
+        warns.push(`Malformed image format suffix at line ${line}: ![${block.label}](…)`);
+    }
+    return warns;
+}
+/**
+ * Non-blocking notices for extension syntax that is not modeled in the editor tree,
+ * plus unresolved reference links. Narrowed automatically for features handled by
+ * `parseMarkdownDocument` (tables, callouts, toggles, columns, `::toc`, task lists).
+ */
+export function collectExtensionSyntaxWarnings(source, fencePairs, fenceCharRanges = []) {
+    const warns = [];
+    const fenceLines = fenceCoveredLineIndices(fencePairs);
+    const rows = splitLinesWithOffsets(source);
+    const syncedLineRe = /\{\{\s*block:/;
+    for (let li = 0; li < rows.length; li++) {
+        if (lineInsideFence(li, fenceLines))
+            continue;
+        const line = rows[li].line;
+        if (syncedLineRe.test(line)) {
+            warns.push(`Line ${li + 1}: synced block syntax (\`{{block:…}}\`) is recognized but not yet editable as a structured block.`);
+        }
+    }
+    warns.push(...collectUnresolvedReferenceLinkWarnings(source, fenceCharRanges));
+    warns.push(...collectMalformedImageSuffixWarnings(source, fenceCharRanges));
+    return warns;
+}

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

@@ -0,0 +1,3 @@
+import type { EditorBlock } from './types';
+/** Deepest block whose source range contains `offset` (prefers later start on ties). */
+export declare function findEditorBlockIdAtSourceOffset(blocks: readonly EditorBlock[], offset: number): string | null;

package/dist/editor/model/findBlockAtSourceOffset.js

@@ -0,0 +1,20 @@
+/** Deepest block whose source range contains `offset` (prefers later start on ties). */
+export function findEditorBlockIdAtSourceOffset(blocks, offset) {
+    let bestId = null;
+    let bestStart = -1;
+    function walk(list) {
+        for (const block of list) {
+            if (block.sourceRange.synthetic || block.sourceRange.start < 0)
+                continue;
+            const { start, end } = block.sourceRange;
+            if (offset >= start && offset <= end && start >= bestStart) {
+                bestStart = start;
+                bestId = block.id;
+            }
+            if (block.children?.length)
+                walk(block.children);
+        }
+    }
+    walk(blocks);
+    return bestId;
+}

package/dist/editor/model/fixtures/serialization-fidelity/reorder-gaps.svelte

@@ -0,0 +1,4 @@
+
+<p>aa</p>
+<p>bb</p>
+<p>cc</p>

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

@@ -0,0 +1,25 @@
+/** Post-command caret target resolved by `MarkdownEditor.setFocusOutcome`. */
+export type FocusOutcome = {
+    mode: 'blockId';
+    blockId: string;
+    plain?: {
+        start: number;
+        end: number;
+    };
+    tableCell?: import('./types.js').TableCellAddress;
+} | {
+    mode: 'siblingOffset';
+    anchorBlockId: string;
+    offset: number;
+    plain?: {
+        start: number;
+        end: number;
+    };
+} | {
+    mode: 'sourceOffset';
+    offset: number;
+    plain?: {
+        start: number;
+        end: number;
+    };
+};

package/dist/editor/model/focusOutcome.js

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

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

@@ -0,0 +1,16 @@
+import type { InlineDraftCommitBlockType } from './reparseOptions';
+import type { EditorDocument } from './types';
+export type IncrementalReparseResult = {
+    ok: true;
+    document: EditorDocument;
+} | {
+    ok: false;
+    reason: string;
+};
+/** True when `[rangeStart, rangeEnd)` intersects a link-reference definition line. */
+export declare function editRangeTouchesLinkDefinitions(source: string, rangeStart: number, rangeEnd: number): boolean;
+/**
+ * Incremental structural reparse for a single top-level block slice (phase 1).
+ * Falls back when validation fails — caller should run full `#reparse`.
+ */
+export declare function tryIncrementalReparse(source: string, fileName: string | null, prevDoc: EditorDocument, blockIndex: number, expectedType: InlineDraftCommitBlockType): IncrementalReparseResult;

package/dist/editor/model/incrementalReparse.js

@@ -0,0 +1,111 @@
+import { collectDefinitionsAndExcluded } from '../plugins/links-images/parse-links-images';
+import { applyInlineSecondPassToBlockIndices } from './inlineSecondPass';
+import { parseMarkdownDocument } from './parseMarkdownDocument';
+import { reconcileBlockIds } from './reconcileBlockIds';
+function offsetToLine(source, offset) {
+    let line = 0;
+    const upto = Math.min(Math.max(0, offset), source.length);
+    for (let k = 0; k < upto; k++) {
+        if (source[k] === '\n')
+            line++;
+    }
+    return line;
+}
+function sourceRangeAtOffsets(source, start, end) {
+    const safeEnd = Math.max(start, end);
+    return {
+        start,
+        end: safeEnd,
+        startLine: offsetToLine(source, start),
+        endLine: offsetToLine(source, safeEnd > start ? safeEnd - 1 : start)
+    };
+}
+function shiftSourceRange(range, delta, source) {
+    if (range.synthetic || range.start < 0)
+        return range;
+    return sourceRangeAtOffsets(source, range.start + delta, range.end + delta);
+}
+function offsetParsedBlock(block, sliceOffset, fullSource) {
+    const sr = block.sourceRange;
+    const start = sr.start + sliceOffset;
+    const end = sr.end + sliceOffset;
+    return {
+        ...block,
+        sourceRange: sourceRangeAtOffsets(fullSource, start, end)
+    };
+}
+/** True when `[rangeStart, rangeEnd)` intersects a link-reference definition line. */
+export function editRangeTouchesLinkDefinitions(source, rangeStart, rangeEnd) {
+    const { excluded } = collectDefinitionsAndExcluded(source);
+    return excluded.some((r) => r.start < rangeEnd && r.end > rangeStart);
+}
+function validateNextBlockFingerprint(prevSource, source, nextBlock, delta) {
+    if (nextBlock.sourceRange.synthetic || nextBlock.sourceRange.start < 0)
+        return true;
+    const oldStart = nextBlock.sourceRange.start;
+    const oldEnd = nextBlock.sourceRange.end;
+    const before = prevSource.slice(oldStart, oldEnd);
+    const after = source.slice(oldStart + delta, oldEnd + delta);
+    return before === after;
+}
+/**
+ * Incremental structural reparse for a single top-level block slice (phase 1).
+ * Falls back when validation fails — caller should run full `#reparse`.
+ */
+export function tryIncrementalReparse(source, fileName, prevDoc, blockIndex, expectedType) {
+    const prevBlocks = prevDoc.blocks;
+    const prevBlock = prevBlocks[blockIndex];
+    if (!prevBlock)
+        return { ok: false, reason: 'Invalid block index.' };
+    if (prevBlock.type !== expectedType) {
+        return { ok: false, reason: 'Block type mismatch.' };
+    }
+    if (prevBlock.sourceRange.synthetic || prevBlock.sourceRange.start < 0) {
+        return { ok: false, reason: 'Block is not incrementally reparseable.' };
+    }
+    const prevSource = prevDoc.source;
+    const oldStart = prevBlock.sourceRange.start;
+    const oldEnd = prevBlock.sourceRange.end;
+    const delta = source.length - prevSource.length;
+    const newEnd = oldEnd + delta;
+    if (editRangeTouchesLinkDefinitions(prevSource, oldStart, newEnd)) {
+        return { ok: false, reason: 'Edit touches link-reference definitions.' };
+    }
+    if (editRangeTouchesLinkDefinitions(source, oldStart, newEnd)) {
+        return { ok: false, reason: 'Edit touches link-reference definitions.' };
+    }
+    const slice = source.slice(oldStart, newEnd);
+    const sliceDoc = parseMarkdownDocument(slice, fileName);
+    const parsedBlocks = sliceDoc.blocks.filter((b) => !b.sourceRange.synthetic && b.sourceRange.start >= 0);
+    if (parsedBlocks.length !== 1 || parsedBlocks[0].type !== expectedType) {
+        return { ok: false, reason: 'Slice did not parse to a single expected block.' };
+    }
+    let parsedBlock = offsetParsedBlock(parsedBlocks[0], oldStart, source);
+    const [reconciled] = reconcileBlockIds([prevBlock], [parsedBlock]);
+    parsedBlock = reconciled ?? parsedBlock;
+    const outBlocks = [];
+    for (let i = 0; i < prevBlocks.length; i++) {
+        if (i === blockIndex) {
+            outBlocks.push(parsedBlock);
+            continue;
+        }
+        const prev = prevBlocks[i];
+        if (i < blockIndex) {
+            outBlocks.push(prev);
+            continue;
+        }
+        outBlocks.push({
+            ...prev,
+            sourceRange: shiftSourceRange(prev.sourceRange, delta, source)
+        });
+    }
+    if (blockIndex + 1 < prevBlocks.length) {
+        const nextPrev = prevBlocks[blockIndex + 1];
+        if (!validateNextBlockFingerprint(prevSource, source, nextPrev, delta)) {
+            return { ok: false, reason: 'Next block source fingerprint mismatch.' };
+        }
+    }
+    let document = { source, fileName, blocks: outBlocks };
+    document = applyInlineSecondPassToBlockIndices(document, [blockIndex]);
+    return { ok: true, document };
+}

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

@@ -0,0 +1,22 @@
+export type { BlockPath, DocumentSelection, EditorBlock, EditorBlockType, EditorDocument, EditorHistorySnapshot, EditorOperation, EditorSelection, EditorTransaction, InlineCodeNode, InlineEmphasisNode, InlineNode, InlineStrongNode, InlineTextNode, PlainTextRange, SourceRange, SourceSliceRange } from './types';
+export { clampSelection, normalizeSelectionRange, stableBlockId, syntheticRange } from './types';
+export { applyEditorTransaction, deleteBlockTransaction, duplicateBlockTransaction, type TransactionBuildResult } from './editorTransactions';
+export { applyBlockTreeDrop, blockTreeDropTransaction, canBlockTreeDrop, tabReparentBlockTransaction, type TreeDropPlacement } from './blockTreeDrop';
+export { blockCanMoveSibling, blockTreeDepth, canNestUnder } from './blockTree';
+export { applyListItemInlineWrapTransaction, applyQuoteParagraphInlineWrapTransaction, deleteListItemTransaction, deleteQuoteParagraphTransaction, duplicateListItemTransaction, duplicateQuoteParagraphTransaction, listItemTreeDropTransaction, listRegionStructMutation, moveListItemSiblingTransaction, moveQuoteParagraphSiblingTransaction, calloutBodyTreeDropTransaction, calloutDocumentStructMutation, deleteCalloutChildTransaction, duplicateCalloutChildTransaction, moveCalloutChildSiblingTransaction, quoteParagraphReorderTransaction, quoteStructMutationTransaction, siblingFocusIdForCalloutDelete, siblingFocusIdForListDelete, siblingFocusIdForQuoteDelete } from './nestedContainerTransactions';
+export { findEditorBlockById, tryRemapDocumentSelectionBlockId } from './documentSelection';
+export { documentSelectionFromSourceOffset } from './documentSelectionFromSource';
+export type { FocusOutcome } from './focusOutcome';
+export { findEditorBlockIdAtSourceOffset } from './findBlockAtSourceOffset';
+export { blockIdentityFingerprint, reconcileBlockIds } from './reconcileBlockIds';
+export { parseMarkdownDocument } from './parseMarkdownDocument';
+export { EMPTY_PARAGRAPH_MARKER, EMPTY_PARAGRAPH_INSERTION, normalizeEmptySource, isDisplayEmptyParagraph, isSoleEmptyParagraphDocument, emptyParagraphBlockData } from './emptyParagraph';
+export { applyInlineSecondPass, applyInlineSecondPassToBlockIndices } from './inlineSecondPass';
+export { tryIncrementalReparse, editRangeTouchesLinkDefinitions, type IncrementalReparseResult } from './incrementalReparse';
+export { mergeDraftInlineWithParser, draftInlineMergeFingerprint } from './inlineDraftMerge';
+export { FULL_REPARSE, type ReparseOptions, type ReparseKind, type InlineDraftCommitBlockType } from './reparseOptions';
+export { serializeEditorBlock, serializeMarkdownDocument, serializeMarkdownDocumentPreserving, serializeParagraphData } from './serializeMarkdownDocument';
+export { serializeInlineNodes } from './serializeInlineNodes';
+export type { InlineWrapKind } from './inlineEditCommands';
+export { applyParagraphShortcut, applyStructuralMarkdownShortcut, isStructuralMarkdownShortcutLine, isStructuralMarkdownShortcutTrigger, markerOnlyListShortcutMarkdown, buildStructuralShortcutFocusOutcome, convertHeadingLevel, convertHeadingToParagraph, convertParagraphToHeading, deleteBlock, duplicateBlock, EDITOR_HISTORY_LIMIT, headingBodySourceRange, headingMarkdown, headingPlainOffsetToSourceOffset, buildEmptyParagraphInsertTransaction, insertEmptyParagraphRelative, mergeWithPreviousBlock, moveBlockDown, moveBlockToIndex, moveBlockUp, applyInlineWrap, paragraphBlockFromPlainText, paragraphBlockToPlainText, paragraphDisplayPlain, headingDisplayPlain, paragraphPlainOffsetToSourceOffset, replaceBlockMarkdownSlice, replaceSourceRange, splitBlockAtPlainOffset, swapAdjacentBlocks, updateBlockPlainText, type SourceEditResult, type SplitBlockAtPlainOffsetResult } from './blockEditCommands';
+export { documentBlocksToRenderBlocks } from './documentToRenderBlocks';