@blankdotpage/cake 0.1.68 → 0.1.69

package/dist/cake/core/runtime.js

@@ -1,5 +1,6 @@
-import { CursorSourceBuilder, } from "./mapping/cursor-source-map";
+import { CursorSourceBuilder, createCompositeCursorSourceMap, } from "./mapping/cursor-source-map";
 import { graphemeSegments } from "../shared/segmenter";
+import { getEditorTextModelForDoc, } from "../editor/internal/editor-text-model";
 /** Type guard to check if a command is a structural edit */
 export function isStructuralEdit(command) {
     return (command.type === "insert" ||
@@ -149,19 +150,33 @@ export function createRuntimeForTests(extensions) {
 export function createRuntimeFromRegistry(registry) {
     const { toggleMarkerToSpec, inclusiveAtEndByKind, parseBlockFns, parseInlineFns, serializeBlockFns, serializeInlineFns, normalizeBlockFns, normalizeInlineFns, onEditFns, structuralReparsePolicies, domInlineRenderers, domBlockRenderers, } = registry;
     const isInclusiveAtEnd = (kind) => inclusiveAtEndByKind.get(kind) ?? true;
-    const context = {
+    const removedBlockSentinel = Symbol("removed-block");
+    const removedInlineSentinel = Symbol("removed-inline");
+    const normalizedDocCache = new WeakMap();
+    const normalizedBlockCache = new WeakMap();
+    const normalizedInlineCache = new WeakMap();
+    const serializedDocCache = new WeakMap();
+    const serializedBlockCache = new WeakMap();
+    const serializedInlineCache = new WeakMap();
+    const segmentedDocCache = new WeakMap();
+    const emptyCursorMap = new CursorSourceBuilder().build().map;
+    const emptySerialized = {
+        source: "",
+        map: emptyCursorMap,
+    };
+    const extensionContext = {
         parseInline: (source, start, end) => parseInlineRange(source, start, end),
         serializeInline: (inline) => serializeInline(inline),
         serializeBlock: (block) => serializeBlock(block),
     };
     function parseBlockAt(source, start) {
         for (const parseBlock of parseBlockFns) {
-            const result = parseBlock(source, start, context);
+            const result = parseBlock(source, start, extensionContext);
             if (result) {
                 return result;
             }
         }
-        return parseLiteralBlock(source, start, context);
+        return parseLiteralBlock(source, start, extensionContext);
     }
     function parseInlineRange(source, start, end) {
         const inlines = [];
@@ -169,7 +184,7 @@ export function createRuntimeFromRegistry(registry) {
         while (pos < end) {
             let matched = false;
             for (const parseInline of parseInlineFns) {
-                const result = parseInline(source, pos, end, context);
+                const result = parseInline(source, pos, end, extensionContext);
                 if (result) {
                     inlines.push(result.inline);
                     pos = result.nextPos;
@@ -205,6 +220,10 @@ export function createRuntimeFromRegistry(registry) {
         return { type: "doc", blocks };
     }
     function serialize(doc) {
+        const cached = serializedDocCache.get(doc);
+        if (cached) {
+            return cached;
+        }
         const builder = new CursorSourceBuilder();
         const blocks = doc.blocks;
         blocks.forEach((block, index) => {
@@ -214,41 +233,67 @@ export function createRuntimeFromRegistry(registry) {
                 builder.appendText("\n");
             }
         });
-        return builder.build();
+        const serialized = builder.build();
+        serializedDocCache.set(doc, serialized);
+        return serialized;
     }
     function serializeBlock(block) {
+        const cached = serializedBlockCache.get(block);
+        if (cached) {
+            return cached;
+        }
         for (const serializeBlockFn of serializeBlockFns) {
-            const result = serializeBlockFn(block, context);
+            const result = serializeBlockFn(block, extensionContext);
             if (result) {
+                serializedBlockCache.set(block, result);
                 return result;
             }
         }
         if (block.type === "paragraph") {
-            return serializeParagraph(block, serializeInline);
+            const result = serializeParagraph(block, (inline) => serializeInline(inline));
+            serializedBlockCache.set(block, result);
+            return result;
         }
         if (block.type === "block-wrapper") {
-            return serializeBlockWrapper(block, serializeBlock);
+            const result = serializeBlockWrapper(block, (child) => serializeBlock(child));
+            serializedBlockCache.set(block, result);
+            return result;
         }
-        return { source: "", map: new CursorSourceBuilder().build().map };
+        serializedBlockCache.set(block, emptySerialized);
+        return emptySerialized;
     }
     function serializeInline(inline) {
+        const cached = serializedInlineCache.get(inline);
+        if (cached) {
+            return cached;
+        }
         for (const serializeInlineFn of serializeInlineFns) {
-            const result = serializeInlineFn(inline, context);
+            const result = serializeInlineFn(inline, extensionContext);
             if (result) {
+                serializedInlineCache.set(inline, result);
                 return result;
             }
         }
         if (inline.type === "text") {
             const builder = new CursorSourceBuilder();
             builder.appendText(inline.text);
-            return builder.build();
+            const result = builder.build();
+            serializedInlineCache.set(inline, result);
+            return result;
         }
         if (inline.type === "inline-wrapper") {
-            return serializeInlineWrapper(inline, serializeInline);
+            const result = serializeInlineWrapper(inline, (child) => serializeInline(child));
+            serializedInlineCache.set(inline, result);
+            return result;
         }
-        return { source: "", map: new CursorSourceBuilder().build().map };
+        serializedInlineCache.set(inline, emptySerialized);
+        return emptySerialized;
     }
     function normalize(doc) {
+        const cached = normalizedDocCache.get(doc);
+        if (cached) {
+            return cached;
+        }
         let changed = false;
         const blocks = [];
         for (const block of doc.blocks) {
@@ -262,19 +307,28 @@ export function createRuntimeFromRegistry(registry) {
             }
             blocks.push(normalized);
         }
-        if (!changed) {
-            return doc;
+        const normalized = changed
+            ? {
+                type: "doc",
+                blocks,
+            }
+            : doc;
+        normalizedDocCache.set(doc, normalized);
+        if (normalized !== doc) {
+            normalizedDocCache.set(normalized, normalized);
         }
-        return {
-            type: "doc",
-            blocks,
-        };
+        return normalized;
     }
     function normalizeBlock(block) {
+        const cached = normalizedBlockCache.get(block);
+        if (cached !== undefined) {
+            return cached === removedBlockSentinel ? null : cached;
+        }
         let next = block;
         for (const normalizeBlockFn of normalizeBlockFns) {
             const result = normalizeBlockFn(next);
             if (result === null) {
+                normalizedBlockCache.set(block, removedBlockSentinel);
                 return null;
             }
             next = result;
@@ -283,46 +337,53 @@ export function createRuntimeFromRegistry(registry) {
             let changed = next !== block;
             const content = [];
             for (const inline of next.content) {
-                const normalized = normalizeInline(inline);
-                if (normalized === null) {
+                const normalizedInline = normalizeInline(inline);
+                if (normalizedInline === null) {
                     changed = true;
                     continue;
                 }
-                if (normalized !== inline) {
+                if (normalizedInline !== inline) {
                     changed = true;
                 }
-                content.push(normalized);
+                content.push(normalizedInline);
             }
             if (!changed) {
+                normalizedBlockCache.set(block, next);
                 return next;
             }
-            return {
+            const normalized = {
                 ...next,
                 content,
             };
+            normalizedBlockCache.set(block, normalized);
+            return normalized;
         }
         if (next.type === "block-wrapper") {
             let changed = next !== block;
             const blocks = [];
             for (const child of next.blocks) {
-                const normalized = normalizeBlock(child);
-                if (normalized === null) {
+                const normalizedChild = normalizeBlock(child);
+                if (normalizedChild === null) {
                     changed = true;
                     continue;
                 }
-                if (normalized !== child) {
+                if (normalizedChild !== child) {
                     changed = true;
                 }
-                blocks.push(normalized);
+                blocks.push(normalizedChild);
             }
             if (!changed) {
+                normalizedBlockCache.set(block, next);
                 return next;
             }
-            return {
+            const normalized = {
                 ...next,
                 blocks,
             };
+            normalizedBlockCache.set(block, normalized);
+            return normalized;
         }
+        normalizedBlockCache.set(block, next);
         return next;
     }
     function applyInlineNormalizers(inline) {
@@ -337,8 +398,13 @@ export function createRuntimeFromRegistry(registry) {
         return next;
     }
     function normalizeInline(inline) {
+        const cached = normalizedInlineCache.get(inline);
+        if (cached !== undefined) {
+            return cached === removedInlineSentinel ? null : cached;
+        }
         const pre = applyInlineNormalizers(inline);
         if (!pre) {
+            normalizedInlineCache.set(inline, removedInlineSentinel);
             return null;
         }
         let next = pre;
@@ -350,31 +416,188 @@ export function createRuntimeFromRegistry(registry) {
                     .filter((child) => child !== null),
             };
         }
-        return applyInlineNormalizers(next);
+        const normalized = applyInlineNormalizers(next);
+        normalizedInlineCache.set(inline, normalized ?? removedInlineSentinel);
+        return normalized;
     }
-    function createState(source, selection = defaultSelection) {
-        const doc = parse(source);
-        const normalized = normalize(doc);
-        const serialized = serialize(normalized);
+    function createTopLevelBlockSegment(block) {
+        const serialized = serializeBlock(block);
         return {
+            block,
             source: serialized.source,
-            selection,
             map: serialized.map,
-            doc: normalized,
-            runtime: runtime,
+            sourceLength: serialized.source.length,
+            cursorLength: serialized.map.cursorLength,
+        };
+    }
+    function hasSharedTopLevelBlockIdentity(previousDoc, nextDoc) {
+        if (previousDoc === nextDoc) {
+            return true;
+        }
+        if (previousDoc.blocks.length === 0 || nextDoc.blocks.length === 0) {
+            return false;
+        }
+        const previousBlocks = new Set(previousDoc.blocks);
+        return nextDoc.blocks.some((block) => previousBlocks.has(block));
+    }
+    function buildTopLevelSegments(doc, previous) {
+        const previousByBlock = new Map();
+        if (previous) {
+            for (const segment of previous.segments) {
+                previousByBlock.set(segment.block, segment);
+            }
+        }
+        return doc.blocks.map((block) => {
+            const reused = previousByBlock.get(block);
+            return reused ?? createTopLevelBlockSegment(block);
+        });
+    }
+    function buildPrefixIndexes(segments) {
+        const cursorStarts = [];
+        const sourceStarts = [];
+        let cursorOffset = 0;
+        let sourceOffset = 0;
+        for (let i = 0; i < segments.length; i += 1) {
+            const segment = segments[i];
+            cursorStarts.push(cursorOffset);
+            sourceStarts.push(sourceOffset);
+            cursorOffset += segment?.cursorLength ?? 0;
+            sourceOffset += segment?.sourceLength ?? 0;
+            if (i < segments.length - 1) {
+                cursorOffset += 1;
+                sourceOffset += 1;
+            }
+        }
+        return {
+            cursorStarts,
+            sourceStarts,
+            totalCursorLength: cursorOffset,
+            totalSourceLength: sourceOffset,
+        };
+    }
+    function serializeSegmentRange(segments, startIndex, endIndex) {
+        if (startIndex >= endIndex) {
+            return "";
+        }
+        let source = "";
+        for (let i = startIndex; i < endIndex; i += 1) {
+            const segment = segments[i];
+            if (!segment) {
+                continue;
+            }
+            source += segment.source;
+            if (i < segments.length - 1) {
+                source += "\n";
+            }
+        }
+        return source;
+    }
+    function sourceOffsetForBlockStart(state, blockIndex) {
+        if (blockIndex <= 0) {
+            return 0;
+        }
+        if (blockIndex >= state.segments.length) {
+            return state.source.length;
+        }
+        return state.sourceStarts[blockIndex] ?? state.source.length;
+    }
+    function buildSegmentedSource(segments, previous) {
+        if (!previous) {
+            return serializeSegmentRange(segments, 0, segments.length);
+        }
+        const previousSegments = previous.segments;
+        let prefix = 0;
+        const maxPrefix = Math.min(previousSegments.length, segments.length);
+        while (prefix < maxPrefix &&
+            previousSegments[prefix]?.block === segments[prefix]?.block) {
+            prefix += 1;
+        }
+        let suffix = 0;
+        const maxSuffix = Math.min(previousSegments.length - prefix, segments.length - prefix);
+        while (suffix < maxSuffix &&
+            previousSegments[previousSegments.length - 1 - suffix]?.block ===
+                segments[segments.length - 1 - suffix]?.block) {
+            suffix += 1;
+        }
+        if (prefix === previousSegments.length && prefix === segments.length) {
+            return previous.source;
+        }
+        const oldStart = sourceOffsetForBlockStart(previous, prefix);
+        const oldEnd = sourceOffsetForBlockStart(previous, previousSegments.length - suffix);
+        const middle = serializeSegmentRange(segments, prefix, segments.length - suffix);
+        return (previous.source.slice(0, oldStart) +
+            middle +
+            previous.source.slice(oldEnd));
+    }
+    function buildSegmentedDocState(doc, previous) {
+        const cached = segmentedDocCache.get(doc);
+        if (cached) {
+            return cached;
+        }
+        const segments = buildTopLevelSegments(doc, previous);
+        const { cursorStarts, sourceStarts, totalCursorLength, totalSourceLength, } = buildPrefixIndexes(segments);
+        const source = buildSegmentedSource(segments, previous);
+        const map = createCompositeCursorSourceMap({
+            segments: segments.map((segment) => ({
+                map: segment.map,
+                cursorLength: segment.cursorLength,
+                sourceLength: segment.sourceLength,
+            })),
+            cursorStarts,
+            sourceStarts,
+            cursorLength: totalCursorLength,
+        });
+        const segmented = {
+            doc,
+            segments,
+            cursorStarts,
+            sourceStarts,
+            totalCursorLength,
+            totalSourceLength,
+            source,
+            map,
         };
+        segmentedDocCache.set(doc, segmented);
+        return segmented;
     }
-    function createStateFromDoc(doc, selection = defaultSelection) {
+    function buildStateFromDoc(doc, selection, options) {
         const normalized = normalize(doc);
-        const serialized = serialize(normalized);
+        const mode = options?.mode ?? "incremental";
+        const previousSegmented = mode === "incremental" && options?.previousState
+            ? segmentedDocCache.get(options.previousState.doc)
+            : undefined;
+        const reusablePrevious = previousSegmented &&
+            hasSharedTopLevelBlockIdentity(previousSegmented.doc, normalized)
+            ? previousSegmented
+            : undefined;
+        const segmented = buildSegmentedDocState(normalized, reusablePrevious);
         return {
-            source: serialized.source,
+            source: segmented.source,
             selection,
-            map: serialized.map,
+            map: segmented.map,
             doc: normalized,
             runtime: runtime,
         };
     }
+    function createState(source, selection = defaultSelection) {
+        const doc = parse(source);
+        return buildStateFromDoc(doc, selection, { mode: "full" });
+    }
+    function createStateFromDoc(doc, selection = defaultSelection, options) {
+        return buildStateFromDoc(doc, selection, options);
+    }
+    function isIncrementalDerivationCandidate(command, selection) {
+        if (selection.start !== selection.end) {
+            return false;
+        }
+        if (command.type === "insert") {
+            return command.text.length > 0 && !command.text.includes("\n");
+        }
+        return (command.type === "delete-backward" ||
+            command.type === "delete-forward" ||
+            command.type === "insert-line-break" ||
+            command.type === "insert-hard-line-break");
+    }
     function shouldReparseAfterStructuralEdit(command) {
         if (structuralReparsePolicies.length === 0) {
             return true;
@@ -491,14 +714,19 @@ export function createRuntimeFromRegistry(registry) {
                 }
                 return state;
             }
-            // Structural edits operate directly on the current doc tree. To support
-            // markdown-first behavior while typing, we reparse from the resulting
-            // source and then remap the caret through source space so it stays stable
-            // even when marker characters become source-only.
-            const interim = createStateFromDoc(structural.doc);
+            // Structural edits operate on the doc tree first. Common collapsed
+            // typing/edit flows stay on the incremental segmented path when policy
+            // allows; everything else takes the explicit full fallback path through
+            // source + parse.
+            const shouldReparse = shouldReparseAfterStructuralEdit(command);
+            const useIncrementalSegmentedDerivation = !shouldReparse && isIncrementalDerivationCandidate(command, selection);
+            const interim = createStateFromDoc(structural.doc, defaultSelection, {
+                mode: useIncrementalSegmentedDerivation ? "incremental" : "full",
+                previousState: useIncrementalSegmentedDerivation ? state : undefined,
+            });
             const interimAffinity = structural.nextAffinity ?? "forward";
             const caretSource = interim.map.cursorToSource(structural.nextCursor, interimAffinity);
-            if (!shouldReparseAfterStructuralEdit(command)) {
+            if (useIncrementalSegmentedDerivation) {
                 const caretCursor = interim.map.sourceToCursor(caretSource, interimAffinity);
                 return {
                     ...interim,
@@ -536,11 +764,12 @@ export function createRuntimeFromRegistry(registry) {
         return state;
     }
     function applyStructuralEdit(command, doc, selection) {
-        const lines = flattenDocToLines(doc);
+        const textModel = getEditorTextModelForDoc(doc);
+        const lines = textModel.getStructuralLines();
         if (lines.length === 0) {
             return null;
         }
-        const docCursorLength = cursorLengthForLines(lines);
+        const docCursorLength = textModel.getCursorLength();
         const cursorStart = Math.max(0, Math.min(docCursorLength, Math.min(selection.start, selection.end)));
         const cursorEnd = Math.max(0, Math.min(docCursorLength, Math.max(selection.start, selection.end)));
         const affinity = selection.affinity ?? "forward";
@@ -582,12 +811,12 @@ export function createRuntimeFromRegistry(registry) {
         const shouldReplacePlaceholder = command.type === "insert" &&
             replaceText.length > 0 &&
             range.start === range.end &&
-            graphemeAtCursor(lines, range.start) === "\u200B";
+            textModel.getGraphemeAtCursor(range.start) === "\u200B";
         const effectiveRange = shouldReplacePlaceholder
             ? { start: range.start, end: Math.min(docCursorLength, range.start + 1) }
             : range;
-        const startLoc = resolveCursorToLine(lines, effectiveRange.start);
-        const endLoc = resolveCursorToLine(lines, effectiveRange.end);
+        const startLoc = textModel.resolveOffsetToLine(effectiveRange.start);
+        const endLoc = textModel.resolveOffsetToLine(effectiveRange.end);
         const startLine = lines[startLoc.lineIndex];
         const endLine = lines[endLoc.lineIndex];
         if (!startLine || !endLine) {
@@ -615,8 +844,9 @@ export function createRuntimeFromRegistry(registry) {
                     let nextBlocks = updateBlocksAtPath(doc.blocks, prevLine.parentPath, (blocks) => blocks.map((block, index) => index === prevLine.indexInParent ? nextPrevBlock : block));
                     nextBlocks = updateBlocksAtPath(nextBlocks, endLine.parentPath, (blocks) => blocks.filter((_, index) => index !== endLine.indexInParent));
                     const nextDoc = { ...doc, blocks: nextBlocks };
-                    const nextLines = flattenDocToLines(nextDoc);
-                    const lineStarts = getLineStartOffsets(nextLines);
+                    const nextModel = getEditorTextModelForDoc(nextDoc);
+                    const nextLines = nextModel.getStructuralLines();
+                    const lineStarts = nextModel.getLineOffsets();
                     const mergedLineIndex = nextLines.findIndex((line) => pathsEqual(line.path, prevLine.path));
                     const mergedLine = nextLines[mergedLineIndex];
                     const nextCursor = mergedLineIndex >= 0
@@ -673,8 +903,9 @@ export function createRuntimeFromRegistry(registry) {
                     ...doc,
                     blocks: updateBlocksAtPath(doc.blocks, parentPath, () => nextParentBlocks),
                 };
-                const nextLines = flattenDocToLines(nextDoc);
-                const lineStarts = getLineStartOffsets(nextLines);
+                const nextModel = getEditorTextModelForDoc(nextDoc);
+                const nextLines = nextModel.getStructuralLines();
+                const lineStarts = nextModel.getLineOffsets();
                 const nextLineIndex = Math.min(nextLines.length - 1, startLoc.lineIndex + 1);
                 return {
                     doc: nextDoc,
@@ -693,8 +924,9 @@ export function createRuntimeFromRegistry(registry) {
                     ...doc,
                     blocks: updateBlocksAtPath(doc.blocks, parentPath, () => ensured),
                 };
-                const nextLines = flattenDocToLines(nextDoc);
-                const lineStarts = getLineStartOffsets(nextLines);
+                const nextModel = getEditorTextModelForDoc(nextDoc);
+                const nextLines = nextModel.getStructuralLines();
+                const lineStarts = nextModel.getLineOffsets();
                 const nextLineIndex = Math.min(nextLines.length - 1, startLoc.lineIndex);
                 return {
                     doc: nextDoc,
@@ -724,8 +956,9 @@ export function createRuntimeFromRegistry(registry) {
                         ...doc,
                         blocks: updateBlocksAtPath(doc.blocks, parentPath, () => nextParentBlocks),
                     };
-                    const nextLines = flattenDocToLines(nextDoc);
-                    const lineStarts = getLineStartOffsets(nextLines);
+                    const nextModel = getEditorTextModelForDoc(nextDoc);
+                    const nextLines = nextModel.getStructuralLines();
+                    const lineStarts = nextModel.getLineOffsets();
                     const nextLineIndex = Math.max(0, startLoc.lineIndex - 1);
                     return {
                         doc: nextDoc,
@@ -782,8 +1015,9 @@ export function createRuntimeFromRegistry(registry) {
                     ...doc,
                     blocks: updateBlocksAtPath(doc.blocks, wrapperParentPath, () => nextParentBlocks),
                 };
-                const nextLines = flattenDocToLines(nextDoc);
-                const lineStarts = getLineStartOffsets(nextLines);
+                const nextModel = getEditorTextModelForDoc(nextDoc);
+                const nextLines = nextModel.getStructuralLines();
+                const lineStarts = nextModel.getLineOffsets();
                 const insertedPath = [...wrapperParentPath, wrapperIndexInParent + 1];
                 const insertedLineIndex = nextLines.findIndex((line) => pathsEqual(line.path, insertedPath));
                 const nextCursor = insertedLineIndex >= 0 ? (lineStarts[insertedLineIndex] ?? 0) : 0;
@@ -796,12 +1030,12 @@ export function createRuntimeFromRegistry(registry) {
         }
         const hasSelectedText = effectiveRange.start !== effectiveRange.end;
         const baseMarks = hasSelectedText
-            ? commonMarksAcrossSelection(lines, effectiveRange.start, effectiveRange.end, doc)
+            ? commonMarksAcrossSelection(textModel, lines, effectiveRange.start, effectiveRange.end)
             : marksAtCursor(startRuns, startLoc.offsetInLine, affinity);
         const insertDoc = parse(replaceText);
-        const insertLines = flattenDocToLines(insertDoc);
+        const insertModel = getEditorTextModelForDoc(insertDoc);
         const insertBlocks = insertDoc.blocks;
-        const insertCursorLength = cursorLengthForLines(insertLines);
+        const insertCursorLength = insertModel.getCursorLength();
         const replacementBlocks = buildReplacementBlocks({
             baseMarks,
             beforeRuns,
@@ -817,9 +1051,10 @@ export function createRuntimeFromRegistry(registry) {
             ...doc,
             blocks: updateBlocksAtPath(doc.blocks, parentPath, () => nextParentBlocks),
         };
-        const nextDocCursorLength = cursorLengthForLines(flattenDocToLines(nextDoc));
+        const nextModel = getEditorTextModelForDoc(nextDoc);
+        const nextDocCursorLength = nextModel.getCursorLength();
         const nextCursor = Math.max(0, Math.min(nextDocCursorLength, effectiveRange.start + insertCursorLength));
-        const nextLines = flattenDocToLines(nextDoc);
+        const nextLines = nextModel.getStructuralLines();
         const around = marksAroundCursor(nextDoc, nextCursor);
         const fallbackAffinity = command.type === "delete-backward"
             ? "backward"
@@ -836,8 +1071,8 @@ export function createRuntimeFromRegistry(registry) {
         // If the cursor is at the start of a non-first line (i.e., right after a
         // serialized newline), keep affinity "forward" so selection anchors in the
         // following line, not at the end of the previous one.
-        const nextLoc = resolveCursorToLine(nextLines, nextCursor);
-        const lineStarts = getLineStartOffsets(nextLines);
+        const nextLoc = nextModel.resolveOffsetToLine(nextCursor);
+        const lineStarts = nextModel.getLineOffsets();
         if (nextLoc.lineIndex > 0 &&
             nextLoc.offsetInLine === 0 &&
             nextCursor === (lineStarts[nextLoc.lineIndex] ?? 0)) {
@@ -849,128 +1084,6 @@ export function createRuntimeFromRegistry(registry) {
             nextAffinity,
         };
     }
-    function cursorLengthForLines(lines) {
-        let length = 0;
-        for (const line of lines) {
-            length += line.cursorLength;
-            if (line.hasNewline) {
-                length += 1;
-            }
-        }
-        return length;
-    }
-    function flattenDocToLines(doc) {
-        const entries = [];
-        const visit = (blocks, prefix) => {
-            blocks.forEach((block, index) => {
-                const path = [...prefix, index];
-                if (block.type === "block-wrapper") {
-                    visit(block.blocks, path);
-                    return;
-                }
-                entries.push({ path, block });
-            });
-        };
-        visit(doc.blocks, []);
-        if (entries.length === 0) {
-            return [
-                {
-                    path: [0],
-                    parentPath: [],
-                    indexInParent: 0,
-                    block: { type: "paragraph", content: [] },
-                    text: "",
-                    cursorLength: 0,
-                    hasNewline: false,
-                },
-            ];
-        }
-        return entries.map((entry, i) => {
-            const parentPath = entry.path.slice(0, -1);
-            const indexInParent = entry.path[entry.path.length - 1] ?? 0;
-            const text = blockVisibleText(entry.block);
-            return {
-                path: entry.path,
-                parentPath,
-                indexInParent,
-                block: entry.block,
-                text,
-                cursorLength: graphemeSegments(text).length,
-                hasNewline: i < entries.length - 1,
-            };
-        });
-    }
-    function resolveCursorToLine(lines, cursorOffset) {
-        const total = cursorLengthForLines(lines);
-        const clamped = Math.max(0, Math.min(cursorOffset, total));
-        let start = 0;
-        for (let i = 0; i < lines.length; i += 1) {
-            const line = lines[i];
-            const end = start + line.cursorLength;
-            if (clamped <= end || i === lines.length - 1) {
-                return {
-                    lineIndex: i,
-                    offsetInLine: Math.max(0, Math.min(clamped - start, line.cursorLength)),
-                };
-            }
-            start = end + (line.hasNewline ? 1 : 0);
-            if (line.hasNewline && clamped === start) {
-                return {
-                    lineIndex: Math.min(lines.length - 1, i + 1),
-                    offsetInLine: 0,
-                };
-            }
-        }
-        return {
-            lineIndex: lines.length - 1,
-            offsetInLine: lines[lines.length - 1]?.cursorLength ?? 0,
-        };
-    }
-    function getLineStartOffsets(lines) {
-        const offsets = [];
-        let current = 0;
-        for (const line of lines) {
-            offsets.push(current);
-            current += line.cursorLength + (line.hasNewline ? 1 : 0);
-        }
-        return offsets;
-    }
-    function graphemeAtCursor(lines, cursorOffset) {
-        const loc = resolveCursorToLine(lines, cursorOffset);
-        const line = lines[loc.lineIndex];
-        if (!line) {
-            return null;
-        }
-        if (loc.offsetInLine >= line.cursorLength) {
-            return null;
-        }
-        const segments = Array.from(graphemeSegments(line.text));
-        return segments[loc.offsetInLine]?.segment ?? null;
-    }
-    function blockVisibleText(block) {
-        if (block.type === "paragraph") {
-            return block.content.map(inlineVisibleText).join("");
-        }
-        if (block.type === "block-atom") {
-            return "";
-        }
-        if (block.type === "block-wrapper") {
-            return block.blocks.map(blockVisibleText).join("\n");
-        }
-        return "";
-    }
-    function inlineVisibleText(inline) {
-        if (inline.type === "text") {
-            return inline.text;
-        }
-        if (inline.type === "inline-wrapper") {
-            return inline.children.map(inlineVisibleText).join("");
-        }
-        if (inline.type === "inline-atom") {
-            return " ";
-        }
-        return "";
-    }
     function stableStringify(value) {
         if (value === null || value === undefined) {
             return "";
@@ -1141,13 +1254,14 @@ export function createRuntimeFromRegistry(registry) {
         return null;
     }
     function marksAroundCursor(doc, cursorOffset) {
-        const lines = flattenDocToLines(doc);
-        const loc = resolveCursorToLine(lines, cursorOffset);
+        const textModel = getEditorTextModelForDoc(doc);
+        const lines = textModel.getStructuralLines();
+        const loc = textModel.resolveOffsetToLine(cursorOffset);
         const line = lines[loc.lineIndex];
         if (!line) {
             return { left: [], right: [] };
         }
-        const block = getBlockAtPath(doc.blocks, line.path);
+        const block = line.block;
         if (!block || block.type !== "paragraph") {
             return { left: [], right: [] };
         }
@@ -1321,19 +1435,19 @@ export function createRuntimeFromRegistry(registry) {
         });
         return blocks;
     }
-    function commonMarksAcrossSelection(lines, startCursor, endCursor, doc) {
+    function commonMarksAcrossSelection(textModel, lines, startCursor, endCursor) {
         if (startCursor === endCursor) {
             return [];
         }
-        const startLoc = resolveCursorToLine(lines, startCursor);
-        const endLoc = resolveCursorToLine(lines, endCursor);
+        const startLoc = textModel.resolveOffsetToLine(startCursor);
+        const endLoc = textModel.resolveOffsetToLine(endCursor);
         const slices = [];
         for (let lineIndex = startLoc.lineIndex; lineIndex <= endLoc.lineIndex; lineIndex += 1) {
             const line = lines[lineIndex];
             if (!line) {
                 continue;
             }
-            const block = getBlockAtPath(doc.blocks, line.path);
+            const block = line.block;
             if (!block || block.type !== "paragraph") {
                 continue;
             }
@@ -1545,8 +1659,7 @@ export function createRuntimeFromRegistry(registry) {
             // otherwise we create ambiguous marker sequences (e.g., *italic**​*** doesn't parse).
             const betweenLen = insertAtForward - insertAtBackward;
             const preferBackward = insertAtBackward !== insertAtForward && openLen <= betweenLen;
-            const insertAt = placeholderPos ??
-                (preferBackward ? insertAtBackward : insertAtForward);
+            const insertAt = placeholderPos ?? (preferBackward ? insertAtBackward : insertAtForward);
             const nextSource = placeholderPos !== null
                 ? source.slice(0, insertAt) +
                     openMarker +
@@ -1572,9 +1685,10 @@ export function createRuntimeFromRegistry(registry) {
         }
         const cursorStart = Math.min(selection.start, selection.end);
         const cursorEnd = Math.max(selection.start, selection.end);
-        const linesForSelection = flattenDocToLines(state.doc);
-        const startLoc = resolveCursorToLine(linesForSelection, cursorStart);
-        const endLoc = resolveCursorToLine(linesForSelection, cursorEnd);
+        const selectionModel = getEditorTextModelForDoc(state.doc);
+        const linesForSelection = selectionModel.getStructuralLines();
+        const startLoc = selectionModel.resolveOffsetToLine(cursorStart);
+        const endLoc = selectionModel.resolveOffsetToLine(cursorEnd);
         const splitRunsOnNewlines = (runs) => {
             const split = [];
             for (const run of runs) {
@@ -1612,7 +1726,7 @@ export function createRuntimeFromRegistry(registry) {
             if (startInLine === endInLine) {
                 continue;
             }
-            const block = getBlockAtPath(state.doc.blocks, line.path);
+            const block = line.block;
             if (!block || block.type !== "paragraph") {
                 continue;
             }
@@ -1749,22 +1863,23 @@ export function createRuntimeFromRegistry(registry) {
     }
     function serializeSelection(state, selection) {
         const normalized = normalizeSelection(selection);
-        const lines = flattenDocToLines(state.doc);
-        const docCursorLength = cursorLengthForLines(lines);
+        const textModel = getEditorTextModelForDoc(state.doc);
+        const lines = textModel.getStructuralLines();
+        const docCursorLength = textModel.getCursorLength();
         const cursorStart = Math.max(0, Math.min(docCursorLength, Math.min(normalized.start, normalized.end)));
         const cursorEnd = Math.max(0, Math.min(docCursorLength, Math.max(normalized.start, normalized.end)));
         if (cursorStart === cursorEnd) {
             return "";
         }
-        const startLoc = resolveCursorToLine(lines, cursorStart);
-        const endLoc = resolveCursorToLine(lines, cursorEnd);
+        const startLoc = textModel.resolveOffsetToLine(cursorStart);
+        const endLoc = textModel.resolveOffsetToLine(cursorEnd);
         const blocks = [];
         for (let lineIndex = startLoc.lineIndex; lineIndex <= endLoc.lineIndex; lineIndex += 1) {
             const line = lines[lineIndex];
             if (!line) {
                 continue;
             }
-            const block = getBlockAtPath(state.doc.blocks, line.path);
+            const block = line.block;
             if (!block || block.type !== "paragraph") {
                 continue;
             }
@@ -1833,15 +1948,16 @@ export function createRuntimeFromRegistry(registry) {
     }
     function serializeSelectionToHtml(state, selection) {
         const normalized = normalizeSelection(selection);
-        const lines = flattenDocToLines(state.doc);
-        const docCursorLength = cursorLengthForLines(lines);
+        const textModel = getEditorTextModelForDoc(state.doc);
+        const lines = textModel.getStructuralLines();
+        const docCursorLength = textModel.getCursorLength();
         const cursorStart = Math.max(0, Math.min(docCursorLength, Math.min(normalized.start, normalized.end)));
         const cursorEnd = Math.max(0, Math.min(docCursorLength, Math.max(normalized.start, normalized.end)));
         if (cursorStart === cursorEnd) {
             return "";
         }
-        const startLoc = resolveCursorToLine(lines, cursorStart);
-        const endLoc = resolveCursorToLine(lines, cursorEnd);
+        const startLoc = textModel.resolveOffsetToLine(cursorStart);
+        const endLoc = textModel.resolveOffsetToLine(cursorEnd);
         let html = "";
         let activeList = null;
         const closeList = () => {
@@ -1865,7 +1981,7 @@ export function createRuntimeFromRegistry(registry) {
             if (!line) {
                 continue;
             }
-            const block = getBlockAtPath(state.doc.blocks, line.path);
+            const block = line.block;
             if (!block || block.type !== "paragraph") {
                 continue;
             }
@@ -1948,6 +2064,7 @@ export function createRuntimeFromRegistry(registry) {
         parse,
         serialize,
         createState,
+        createStateFromDoc,
         updateSelection,
         serializeSelection,
         serializeSelectionToHtml,