@blankdotpage/cake 0.1.76 → 0.1.78

package/dist/cake/core/runtime.js

@@ -19,7 +19,6 @@ export function isApplyEditCommand(command) {
         command.type === "delete-forward");
 }
 const defaultSelection = { start: 0, end: 0, affinity: "forward" };
-const WORD_CHARACTER_PATTERN = /[\p{L}\p{N}_]/u;
 function removeFromArray(arr, value) {
     const index = arr.indexOf(value);
     if (index === -1) {
@@ -40,6 +39,8 @@ export function createRuntimeForTests(extensions) {
     const structuralReparsePolicies = [];
     const domInlineRenderers = [];
     const domBlockRenderers = [];
+    const inlineHtmlSerializers = [];
+    const serializeSelectionLineToHtmlFns = [];
     const editor = {
         registerInlineWrapperAffinity: (specs) => {
             for (const spec of specs) {
@@ -125,6 +126,14 @@ export function createRuntimeForTests(extensions) {
             domBlockRenderers.push(fn);
             return () => removeFromArray(domBlockRenderers, fn);
         },
+        registerInlineHtmlSerializer: (fn) => {
+            inlineHtmlSerializers.push(fn);
+            return () => removeFromArray(inlineHtmlSerializers, fn);
+        },
+        registerSerializeSelectionLineToHtml: (fn) => {
+            serializeSelectionLineToHtmlFns.push(fn);
+            return () => removeFromArray(serializeSelectionLineToHtmlFns, fn);
+        },
         registerUI: () => {
             return () => { };
         },
@@ -145,11 +154,13 @@ export function createRuntimeForTests(extensions) {
         structuralReparsePolicies,
         domInlineRenderers,
         domBlockRenderers,
+        inlineHtmlSerializers,
+        serializeSelectionLineToHtmlFns,
     });
     return runtime;
 }
 export function createRuntimeFromRegistry(registry) {
-    const { toggleMarkerToSpec, inclusiveAtEndByKind, parseBlockFns, parseInlineFns, serializeBlockFns, serializeInlineFns, normalizeBlockFns, normalizeInlineFns, onEditFns, structuralReparsePolicies, domInlineRenderers, domBlockRenderers, } = registry;
+    const { toggleMarkerToSpec, inclusiveAtEndByKind, parseBlockFns, parseInlineFns, serializeBlockFns, serializeInlineFns, normalizeBlockFns, normalizeInlineFns, onEditFns, structuralReparsePolicies, domInlineRenderers, domBlockRenderers, inlineHtmlSerializers, serializeSelectionLineToHtmlFns, } = registry;
     const isInclusiveAtEnd = (kind) => inclusiveAtEndByKind.get(kind) ?? true;
     const removedBlockSentinel = Symbol("removed-block");
     const removedInlineSentinel = Symbol("removed-inline");
@@ -348,17 +359,13 @@ export function createRuntimeFromRegistry(registry) {
                 }
                 content.push(normalizedInline);
             }
-            const mergedContent = mergeAdjacentInlines(content);
-            if (mergedContent !== content) {
-                changed = true;
-            }
             if (!changed) {
                 normalizedBlockCache.set(block, next);
                 return next;
             }
             const normalized = {
                 ...next,
-                content: mergedContent,
+                content,
             };
             normalizedBlockCache.set(block, normalized);
             return normalized;
@@ -414,52 +421,17 @@ export function createRuntimeFromRegistry(registry) {
         }
         let next = pre;
         if (next.type === "inline-wrapper") {
-            const children = mergeAdjacentInlines(next.children
-                .map((child) => normalizeInline(child))
-                .filter((child) => child !== null));
             next = {
                 ...next,
-                children,
+                children: next.children
+                    .map((child) => normalizeInline(child))
+                    .filter((child) => child !== null),
             };
         }
         const normalized = applyInlineNormalizers(next);
         normalizedInlineCache.set(inline, normalized ?? removedInlineSentinel);
         return normalized;
     }
-    function mergeAdjacentInlines(inlines) {
-        if (inlines.length < 2) {
-            return inlines;
-        }
-        const merged = [];
-        let changed = false;
-        for (const inline of inlines) {
-            const previous = merged[merged.length - 1];
-            if (previous?.type === "text" && inline.type === "text") {
-                merged[merged.length - 1] = {
-                    ...previous,
-                    text: previous.text + inline.text,
-                };
-                changed = true;
-                continue;
-            }
-            if (previous?.type === "inline-wrapper" &&
-                inline.type === "inline-wrapper" &&
-                previous.kind === inline.kind &&
-                stableStringify(previous.data) === stableStringify(inline.data)) {
-                merged[merged.length - 1] = {
-                    ...previous,
-                    children: mergeAdjacentInlines([
-                        ...previous.children,
-                        ...inline.children,
-                    ]),
-                };
-                changed = true;
-                continue;
-            }
-            merged.push(inline);
-        }
-        return changed ? merged : inlines;
-    }
     function createTopLevelBlockSegment(block) {
         const serialized = serializeBlock(block);
         return {
@@ -611,15 +583,9 @@ export function createRuntimeFromRegistry(registry) {
             ? previousSegmented
             : undefined;
         const segmented = buildSegmentedDocState(normalized, reusablePrevious);
-        const cursorLength = segmented.map.cursorLength;
-        const clampedSelection = {
-            ...selection,
-            start: Math.max(0, Math.min(cursorLength, selection.start)),
-            end: Math.max(0, Math.min(cursorLength, selection.end)),
-        };
         return {
             source: segmented.source,
-            selection: normalizeSelection(clampedSelection),
+            selection,
             map: segmented.map,
             doc: normalized,
             runtime: runtime,
@@ -771,8 +737,7 @@ export function createRuntimeFromRegistry(registry) {
                 previousState: useIncrementalSegmentedDerivation ? state : undefined,
             });
             const interimAffinity = structural.nextAffinity ?? "forward";
-            const interimCursor = Math.max(0, Math.min(interim.map.cursorLength, structural.nextCursor));
-            const caretSource = interim.map.cursorToSource(interimCursor, interimAffinity);
+            const caretSource = interim.map.cursorToSource(structural.nextCursor, interimAffinity);
             if (useIncrementalSegmentedDerivation) {
                 const caretCursor = interim.map.sourceToCursor(caretSource, interimAffinity);
                 return {
@@ -859,27 +824,6 @@ export function createRuntimeFromRegistry(registry) {
             replaceText.length > 0 &&
             range.start === range.end &&
             textModel.getGraphemeAtCursor(range.start) === "\u200B";
-        if (command.type === "insert" && shouldReplacePlaceholder) {
-            const leadingWhitespace = replaceText.match(/^\s+/)?.[0] ?? "";
-            const around = marksAroundCursor(doc, range.start);
-            if (leadingWhitespace.length > 0) {
-                if (isMarksPrefix(around.left, around.right) &&
-                    around.right.length > around.left.length) {
-                    const whitespaceInsert = insertTextBeforePendingPlaceholderInDoc(doc, range.start, leadingWhitespace, around.left);
-                    if (whitespaceInsert) {
-                        const trailingText = replaceText.slice(leadingWhitespace.length);
-                        if (trailingText.length === 0) {
-                            return whitespaceInsert;
-                        }
-                        return applyStructuralEdit({ type: "insert", text: trailingText }, whitespaceInsert.doc, {
-                            start: whitespaceInsert.nextCursor,
-                            end: whitespaceInsert.nextCursor,
-                            affinity: whitespaceInsert.nextAffinity,
-                        });
-                    }
-                }
-            }
-        }
         const effectiveRange = shouldReplacePlaceholder
             ? { start: range.start, end: Math.min(docCursorLength, range.start + 1) }
             : range;
@@ -1232,28 +1176,6 @@ export function createRuntimeFromRegistry(registry) {
         }
         return true;
     }
-    function removeMarkByKind(marks, kind) {
-        let removed = false;
-        return marks.filter((mark) => {
-            if (!removed && mark.kind === kind) {
-                removed = true;
-                return false;
-            }
-            return true;
-        });
-    }
-    function mergeMarksPreservingOrder(...groups) {
-        const next = [];
-        for (const group of groups) {
-            for (const mark of group) {
-                if (next.some((existing) => existing.key === mark.key)) {
-                    continue;
-                }
-                next.push(mark);
-            }
-        }
-        return next;
-    }
     function sliceRuns(runs, startCursor, endCursor) {
         const [left, rest] = splitRunsAt(runs, startCursor);
         const [selected, right] = splitRunsAt(rest, Math.max(0, endCursor - startCursor));
@@ -1362,237 +1284,6 @@ export function createRuntimeFromRegistry(registry) {
         const right = marksAtGraphemeIndex(runs, loc.offsetInLine);
         return { left: left ?? [], right: right ?? [] };
     }
-    function createPendingPlaceholderStateAtCursor(state, cursorOffset, marks) {
-        const textModel = getEditorTextModelForDoc(state.doc);
-        const lines = textModel.getStructuralLines();
-        const loc = textModel.resolveOffsetToLine(cursorOffset);
-        const line = lines[loc.lineIndex];
-        if (!line) {
-            return null;
-        }
-        const block = getBlockAtPath(state.doc.blocks, line.path);
-        if (!block || block.type !== "paragraph") {
-            return null;
-        }
-        const placeholder = "\u200B";
-        const runs = paragraphToRuns(block);
-        const { before, after } = sliceRuns(runs, loc.offsetInLine, loc.offsetInLine);
-        const mergedRuns = normalizeRuns([
-            ...before,
-            { type: "text", text: placeholder, marks },
-            ...after,
-        ]);
-        const nextBlock = {
-            ...block,
-            content: runsToInlines(mergedRuns),
-        };
-        const parentPath = line.path.slice(0, -1);
-        const indexInParent = line.path[line.path.length - 1] ?? 0;
-        const nextDoc = {
-            ...state.doc,
-            blocks: updateBlocksAtPath(state.doc.blocks, parentPath, (blocks) => blocks.map((child, index) => index === indexInParent ? nextBlock : child)),
-        };
-        const next = createStateFromDoc(nextDoc);
-        const sourceHint = state.map.cursorToSource(cursorOffset, "backward");
-        const searchStart = Math.max(0, sourceHint - 4);
-        const placeholderStart = next.source.indexOf(placeholder, searchStart) ?? -1;
-        const resolvedPlaceholderStart = placeholderStart !== -1 ? placeholderStart : next.source.indexOf(placeholder);
-        if (resolvedPlaceholderStart === -1) {
-            return null;
-        }
-        const startCursor = next.map.sourceToCursor(resolvedPlaceholderStart, "forward");
-        return {
-            ...next,
-            selection: {
-                start: startCursor.cursorOffset,
-                end: startCursor.cursorOffset,
-                affinity: "forward",
-            },
-        };
-    }
-    function rewritePendingPlaceholderAtCursor(state, cursorOffset, marks) {
-        const textModel = getEditorTextModelForDoc(state.doc);
-        const lines = textModel.getStructuralLines();
-        const loc = textModel.resolveOffsetToLine(cursorOffset);
-        const line = lines[loc.lineIndex];
-        if (!line) {
-            return null;
-        }
-        const block = getBlockAtPath(state.doc.blocks, line.path);
-        if (!block || block.type !== "paragraph") {
-            return null;
-        }
-        const placeholder = "\u200B";
-        const runs = paragraphToRuns(block);
-        const { before, after } = sliceRuns(runs, loc.offsetInLine, loc.offsetInLine);
-        const replacement = [];
-        const firstAfter = after[0];
-        if (firstAfter?.type === "text" && firstAfter.text.startsWith(placeholder)) {
-            if (marks && marks.length > 0) {
-                replacement.push({ type: "text", text: placeholder, marks });
-            }
-            if (firstAfter.text.length > placeholder.length) {
-                replacement.push({
-                    ...firstAfter,
-                    text: firstAfter.text.slice(placeholder.length),
-                });
-            }
-            replacement.push(...after.slice(1));
-        }
-        else {
-            const lastBefore = before[before.length - 1];
-            if (lastBefore?.type !== "text" ||
-                !lastBefore.text.endsWith(placeholder)) {
-                return null;
-            }
-            const prefix = lastBefore.text.slice(0, -placeholder.length);
-            if (prefix) {
-                replacement.push({ ...lastBefore, text: prefix });
-            }
-            if (marks && marks.length > 0) {
-                replacement.push({ type: "text", text: placeholder, marks });
-            }
-            replacement.push(...after);
-            before.pop();
-        }
-        const mergedRuns = normalizeRuns([...before, ...replacement]);
-        const nextBlock = {
-            ...block,
-            content: runsToInlines(mergedRuns),
-        };
-        const parentPath = line.path.slice(0, -1);
-        const indexInParent = line.path[line.path.length - 1] ?? 0;
-        const nextDoc = {
-            ...state.doc,
-            blocks: updateBlocksAtPath(state.doc.blocks, parentPath, (blocks) => blocks.map((child, index) => index === indexInParent ? nextBlock : child)),
-        };
-        const next = createStateFromDoc(nextDoc);
-        return {
-            ...next,
-            selection: {
-                start: cursorOffset,
-                end: cursorOffset,
-                affinity: marks && marks.length > 0 ? "forward" : "backward",
-            },
-        };
-    }
-    function updatePendingPlaceholderMarksAtCursor(state, cursorOffset, marks) {
-        return rewritePendingPlaceholderAtCursor(state, cursorOffset, marks);
-    }
-    function removePendingPlaceholderAtCursor(state, cursorOffset) {
-        return rewritePendingPlaceholderAtCursor(state, cursorOffset, null);
-    }
-    function getPendingPlaceholderMarksAtCursor(state, cursorOffset) {
-        const textModel = getEditorTextModelForDoc(state.doc);
-        const lines = textModel.getStructuralLines();
-        const loc = textModel.resolveOffsetToLine(cursorOffset);
-        const line = lines[loc.lineIndex];
-        if (!line) {
-            return null;
-        }
-        const block = getBlockAtPath(state.doc.blocks, line.path);
-        if (!block || block.type !== "paragraph") {
-            return null;
-        }
-        const placeholder = "\u200B";
-        const runs = paragraphToRuns(block);
-        const { before, after } = sliceRuns(runs, loc.offsetInLine, loc.offsetInLine);
-        const firstAfter = after[0];
-        if (firstAfter?.type === "text" && firstAfter.text.startsWith(placeholder)) {
-            return firstAfter.marks;
-        }
-        const lastBefore = before[before.length - 1];
-        if (lastBefore?.type === "text" &&
-            lastBefore.text.endsWith(placeholder)) {
-            return lastBefore.marks;
-        }
-        return null;
-    }
-    function insertTextBeforePendingPlaceholderInDoc(doc, cursorOffset, text, marks) {
-        const textModel = getEditorTextModelForDoc(doc);
-        const lines = textModel.getStructuralLines();
-        const loc = textModel.resolveOffsetToLine(cursorOffset);
-        const line = lines[loc.lineIndex];
-        if (!line) {
-            return null;
-        }
-        const block = getBlockAtPath(doc.blocks, line.path);
-        if (!block || block.type !== "paragraph") {
-            return null;
-        }
-        const placeholder = "\u200B";
-        const runs = paragraphToRuns(block);
-        const { before, after } = sliceRuns(runs, loc.offsetInLine, loc.offsetInLine);
-        const firstAfter = after[0];
-        if (firstAfter?.type !== "text" ||
-            !firstAfter.text.startsWith(placeholder)) {
-            return null;
-        }
-        const mergedRuns = normalizeRuns([
-            ...before,
-            ...(text.length > 0 ? [{ type: "text", text, marks }] : []),
-            firstAfter,
-            ...after.slice(1),
-        ]);
-        const nextBlock = {
-            ...block,
-            content: runsToInlines(mergedRuns),
-        };
-        const parentPath = line.path.slice(0, -1);
-        const indexInParent = line.path[line.path.length - 1] ?? 0;
-        const nextDoc = {
-            ...doc,
-            blocks: updateBlocksAtPath(doc.blocks, parentPath, (blocks) => blocks.map((child, index) => index === indexInParent ? nextBlock : child)),
-        };
-        return {
-            doc: nextDoc,
-            nextCursor: cursorOffset + Array.from(graphemeSegments(text)).length,
-            nextAffinity: "forward",
-        };
-    }
-    function hasInlineMarkerBoundaryBefore(source, markerStart) {
-        if (markerStart <= 0) {
-            return true;
-        }
-        return !WORD_CHARACTER_PATTERN.test(source[markerStart - 1] ?? "");
-    }
-    function pickSafeCollapsedToggleMarkerSpec(params) {
-        const { defaultSpec, source, insertAt, affinity } = params;
-        const candidates = Array.from(toggleMarkerToSpec.values()).filter((spec, index, all) => spec.kind === defaultSpec.kind &&
-            all.findIndex((candidate) => candidate.kind === spec.kind &&
-                candidate.open === spec.open &&
-                candidate.close === spec.close) === index);
-        if (candidates.length <= 1) {
-            return defaultSpec;
-        }
-        const previousChar = source[insertAt - 1] ?? "";
-        const nextChar = source[insertAt] ?? "";
-        let bestSpec = defaultSpec;
-        let bestScore = Number.POSITIVE_INFINITY;
-        for (const spec of candidates) {
-            if (spec.open === "_" &&
-                !hasInlineMarkerBoundaryBefore(source, insertAt)) {
-                continue;
-            }
-            let score = 0;
-            if (previousChar && spec.open[0] === previousChar) {
-                score += affinity === "forward" ? 8 : 3;
-            }
-            if (nextChar &&
-                spec.close[spec.close.length - 1] === nextChar) {
-                score += affinity === "backward" ? 8 : 3;
-            }
-            if (spec.open === defaultSpec.open &&
-                spec.close === defaultSpec.close) {
-                score -= 0.5;
-            }
-            if (score < bestScore) {
-                bestSpec = spec;
-                bestScore = score;
-            }
-        }
-        return bestSpec;
-    }
     function preferredAffinityAtGap(left, right, fallback) {
         if (isMarksPrefix(left, right) && right.length > left.length) {
             return "forward";
@@ -1845,49 +1536,51 @@ export function createRuntimeFromRegistry(registry) {
         const openLen = openMarker.length;
         const closeLen = closeMarker.length;
         const placeholder = "\u200B";
-        const markerMark = {
-            kind: markerKind,
-            data: undefined,
-            key: markKey(markerKind, undefined),
-        };
         if (selection.start === selection.end) {
             const caret = selection.start;
-            const pendingPlaceholderMarks = getPendingPlaceholderMarksAtCursor(state, caret);
-            if (pendingPlaceholderMarks) {
-                const hasMarker = pendingPlaceholderMarks.some((mark) => mark.kind === markerKind);
-                const around = marksAroundCursor(state.doc, caret);
-                const nextMarks = hasMarker
-                    ? removeMarkByKind(pendingPlaceholderMarks, markerKind)
-                    : mergeMarksPreservingOrder(around.left, pendingPlaceholderMarks, [markerMark]);
-                const next = nextMarks.length > 0
-                    ? updatePendingPlaceholderMarksAtCursor(state, caret, nextMarks)
-                    : removePendingPlaceholderAtCursor(state, caret);
-                if (next) {
-                    return {
-                        ...next,
-                        selection: {
-                            start: caret,
-                            end: caret,
-                            affinity: "forward",
-                        },
-                    };
-                }
-            }
             // When the caret is at the end boundary of an inline wrapper, toggling the
             // wrapper should "exit" it (so the next character types outside). This is
             // best expressed in cursor space by flipping affinity to "forward" when we
             // are leaving a wrapper of the requested kind.
             const around = marksAroundCursor(state.doc, caret);
             if (isMarksPrefix(around.right, around.left) &&
-                around.left.length > around.right.length &&
-                (selection.affinity ?? "forward") === "backward") {
+                around.left.length > around.right.length) {
                 const exiting = around.left.slice(around.right.length);
                 if (exiting.some((mark) => mark.kind === markerKind)) {
-                    const remainingMarks = removeMarkByKind(around.left, markerKind);
-                    if (!marksEqual(remainingMarks, around.right)) {
-                        const next = createPendingPlaceholderStateAtCursor(state, caret, remainingMarks);
-                        if (next) {
-                            return next;
+                    const toggledExitingIndex = exiting.findIndex((mark) => mark.kind === markerKind);
+                    if (exiting.length > 1 &&
+                        toggledExitingIndex !== -1 &&
+                        toggledExitingIndex < exiting.length - 1) {
+                        return {
+                            ...state,
+                            selection: {
+                                start: caret,
+                                end: caret,
+                                affinity: "forward",
+                            },
+                        };
+                    }
+                    if (exiting.length > 1) {
+                        const insertAtForward = map.cursorToSource(caret, "forward");
+                        const insertAtBackward = map.cursorToSource(caret, "backward");
+                        const between = source.slice(insertAtBackward, insertAtForward);
+                        const markerIndex = between.indexOf(closeMarker);
+                        if (markerIndex !== -1) {
+                            const insertAt = insertAtBackward + markerIndex + closeLen;
+                            const nextSource = source.slice(0, insertAt) +
+                                placeholder +
+                                source.slice(insertAt);
+                            const next = createState(nextSource);
+                            const placeholderStart = insertAt;
+                            const startCursor = next.map.sourceToCursor(placeholderStart, "forward");
+                            return {
+                                ...next,
+                                selection: {
+                                    start: startCursor.cursorOffset,
+                                    end: startCursor.cursorOffset,
+                                    affinity: "forward",
+                                },
+                            };
                         }
                     }
                     return {
@@ -1907,20 +1600,6 @@ export function createRuntimeFromRegistry(registry) {
                 around.right.length > around.left.length) {
                 const entering = around.right.slice(around.left.length);
                 if (entering.some((mark) => mark.kind === markerKind)) {
-                    const remainingMarks = removeMarkByKind(around.right, markerKind);
-                    const next = remainingMarks.length > 0
-                        ? updatePendingPlaceholderMarksAtCursor(state, caret, remainingMarks)
-                        : removePendingPlaceholderAtCursor(state, caret);
-                    if (next) {
-                        return {
-                            ...next,
-                            selection: {
-                                start: caret,
-                                end: caret,
-                                affinity: "backward",
-                            },
-                        };
-                    }
                     const insertAtBackward = map.cursorToSource(caret, "backward");
                     const insertAtForward = map.cursorToSource(caret, "forward");
                     const after = source.slice(insertAtBackward);
@@ -1979,18 +1658,6 @@ export function createRuntimeFromRegistry(registry) {
                     }
                 }
             }
-            if (isMarksPrefix(around.right, around.left) &&
-                around.left.length > around.right.length &&
-                (selection.affinity ?? "forward") === "backward" &&
-                !around.left.some((mark) => mark.kind === markerKind)) {
-                const next = createPendingPlaceholderStateAtCursor(state, caret, [
-                    ...around.left,
-                    markerMark,
-                ]);
-                if (next) {
-                    return next;
-                }
-            }
             // Otherwise, insert an empty marker pair with a zero-width placeholder
             // selected so the next typed character replaces it.
             //
@@ -2012,63 +1679,34 @@ export function createRuntimeFromRegistry(registry) {
                 return null;
             })();
             // When at a boundary between cursor positions (insertAtBackward !== insertAtForward),
-            // only prefer insertAtBackward if the caret is intentionally anchored inside the
-            // left formatting context. If the caret affinity is forward, the user explicitly
-            // exited that wrapper and new markers belong on the forward side of the gap.
-            // Still guard against inserting a longer marker into a shorter boundary run,
-            // which would create ambiguous source (e.g., *italic**​***).
+            // prefer insertAtBackward to keep new markers inside the current formatting context.
+            // However, only do this if the new marker length is <= the boundary marker length,
+            // otherwise we create ambiguous marker sequences (e.g., *italic**​*** doesn't parse).
             const betweenLen = insertAtForward - insertAtBackward;
-            const preferBackward = insertAtBackward !== insertAtForward &&
-                (selection.affinity ?? "forward") === "backward" &&
-                openLen <= betweenLen;
+            const preferBackward = insertAtBackward !== insertAtForward && openLen <= betweenLen;
             const insertAt = placeholderPos ?? (preferBackward ? insertAtBackward : insertAtForward);
-            const insertMarkerSpec = placeholderPos === null
-                ? pickSafeCollapsedToggleMarkerSpec({
-                    defaultSpec: markerSpec,
-                    source,
-                    insertAt,
-                    affinity: selection.affinity ?? "forward",
-                })
-                : markerSpec;
-            const insertOpenMarker = insertMarkerSpec.open;
-            const insertCloseMarker = insertMarkerSpec.close;
-            const insertOpenLen = insertOpenMarker.length;
-            const baseMarks = (selection.affinity ?? "forward") === "backward"
-                ? around.left
-                : around.right;
-            const nextMarks = [
-                ...baseMarks.filter((mark) => mark.kind !== markerKind),
-                markerMark,
-            ];
-            if (placeholderPos !== null) {
-                const next = updatePendingPlaceholderMarksAtCursor(state, caret, nextMarks);
-                if (next) {
-                    return next;
-                }
-            }
-            const docInserted = createPendingPlaceholderStateAtCursor(state, caret, nextMarks);
-            if (docInserted) {
-                return docInserted;
-            }
             const nextSource = placeholderPos !== null
                 ? source.slice(0, insertAt) +
-                    insertOpenMarker +
+                    openMarker +
                     placeholder +
-                    insertCloseMarker +
+                    closeMarker +
                     source.slice(insertAt + placeholder.length)
                 : source.slice(0, insertAt) +
-                    insertOpenMarker +
+                    openMarker +
                     placeholder +
-                    insertCloseMarker +
+                    closeMarker +
                     source.slice(insertAt);
             const next = createState(nextSource);
-            const placeholderStart = insertAt + insertOpenLen;
+            const placeholderStart = insertAt + openLen;
             const startCursor = next.map.sourceToCursor(placeholderStart, "forward");
-            return createStateFromDoc(next.doc, {
-                start: startCursor.cursorOffset,
-                end: startCursor.cursorOffset,
-                affinity: "forward",
-            });
+            return {
+                ...next,
+                selection: {
+                    start: startCursor.cursorOffset,
+                    end: startCursor.cursorOffset,
+                    affinity: "forward",
+                },
+            };
         }
         const cursorStart = Math.min(selection.start, selection.end);
         const cursorEnd = Math.max(selection.start, selection.end);
@@ -2130,6 +1768,11 @@ export function createRuntimeFromRegistry(registry) {
         const hasTargetMark = visibleRunsForDecision.some((run) => run.marks.some((mark) => mark.kind === markerKind));
         const canUnwrap = hasTargetMark &&
             visibleRunsForDecision.every((run) => run.marks.some((mark) => mark.kind === markerKind));
+        const markerMark = {
+            kind: markerKind,
+            data: undefined,
+            key: markKey(markerKind, undefined),
+        };
         const removeMark = (marks) => {
             if (!marks.some((mark) => mark.kind === markerKind)) {
                 return marks;
@@ -2310,18 +1953,12 @@ export function createRuntimeFromRegistry(registry) {
             // Apply marks in reverse order so outer marks wrap inner marks
             const sortedMarks = [...run.marks].reverse();
             for (const mark of sortedMarks) {
-                if (mark.kind === "bold") {
-                    content = `<strong>${content}</strong>`;
-                }
-                else if (mark.kind === "italic") {
-                    content = `<em>${content}</em>`;
-                }
-                else if (mark.kind === "strikethrough") {
-                    content = `<s>${content}</s>`;
-                }
-                else if (mark.kind === "link") {
-                    const url = mark.data?.url ?? "";
-                    content = `<a href="${escapeHtml(url)}">${content}</a>`;
+                for (const serializeMarkToHtml of inlineHtmlSerializers) {
+                    const next = serializeMarkToHtml({ kind: mark.kind, data: mark.data }, content, { escapeHtml });
+                    if (next !== null) {
+                        content = next;
+                        break;
+                    }
                 }
             }
             html += content;
@@ -2341,22 +1978,13 @@ export function createRuntimeFromRegistry(registry) {
         const startLoc = textModel.resolveOffsetToLine(cursorStart);
         const endLoc = textModel.resolveOffsetToLine(cursorEnd);
         let html = "";
-        let activeList = null;
-        const closeList = () => {
-            if (activeList) {
-                html += `</${activeList.type}>`;
-                activeList = null;
-            }
-        };
-        const openList = (type, indent) => {
-            if (activeList &&
-                activeList.type === type &&
-                activeList.indent === indent) {
+        let activeGroup = null;
+        const closeGroup = () => {
+            if (!activeGroup) {
                 return;
             }
-            closeList();
-            html += `<${type}>`;
-            activeList = { type, indent };
+            html += activeGroup.close;
+            activeGroup = null;
         };
         for (let lineIndex = startLoc.lineIndex; lineIndex <= endLoc.lineIndex; lineIndex += 1) {
             const line = lines[lineIndex];
@@ -2373,66 +2001,46 @@ export function createRuntimeFromRegistry(registry) {
                 ? endLoc.offsetInLine
                 : line.cursorLength;
             const selectedRuns = sliceRuns(runs, startInLine, endInLine).selected;
-            // Check if this line is inside a block-wrapper (heading or list)
-            let wrapperKind = null;
-            let wrapperData;
+            const lineHtml = runsToHtml(normalizeRuns(selectedRuns));
+            const lineText = runs
+                .map((r) => (r.type === "text" ? r.text : " "))
+                .join("");
+            let wrapperBlock = null;
             if (line.path.length > 1) {
                 const wrapperPath = line.path.slice(0, -1);
                 const wrapper = getBlockAtPath(state.doc.blocks, wrapperPath);
                 if (wrapper && wrapper.type === "block-wrapper") {
-                    wrapperKind = wrapper.kind;
-                    wrapperData = wrapper.data;
+                    wrapperBlock = wrapper;
                 }
             }
-            // Extract plain text to check for list patterns
-            const plainText = runs
-                .map((r) => (r.type === "text" ? r.text : " "))
-                .join("");
-            const listMatch = plainText.match(/^(\s*)([-*+]|\d+\.)( )(.*)$/);
-            // Determine the HTML content - strip list prefix if it's a list line
-            let lineHtml;
-            if (listMatch && !wrapperKind) {
-                // For list lines, only include the content after the prefix
-                const prefixLength = Array.from(graphemeSegments(`${listMatch[1]}${listMatch[2]}${listMatch[3]}`)).length;
-                const contentRuns = sliceRuns(runs, prefixLength, runs.reduce((sum, r) => sum +
-                    (r.type === "text"
-                        ? Array.from(graphemeSegments(r.text)).length
-                        : 1), 0)).selected;
-                lineHtml = runsToHtml(normalizeRuns(contentRuns));
-            }
-            else {
-                lineHtml = runsToHtml(normalizeRuns(selectedRuns));
-            }
-            if (wrapperKind === "heading") {
-                closeList();
-                const level = Math.min(wrapperData?.level ?? 1, 6);
-                html += `<h${level} style="margin:0">${lineHtml}</h${level}>`;
-            }
-            else if (wrapperKind === "bullet-list") {
-                openList("ul", 0);
-                html += `<li>${lineHtml}</li>`;
-            }
-            else if (wrapperKind === "numbered-list") {
-                openList("ol", 0);
-                html += `<li>${lineHtml}</li>`;
-            }
-            else if (wrapperKind === "blockquote") {
-                closeList();
-                html += `<blockquote>${lineHtml}</blockquote>`;
-            }
-            else if (listMatch) {
-                // Plain paragraph with list markers (cake v3 list model)
-                const isNumbered = /^\d+\.$/.test(listMatch[2]);
-                const indent = Math.floor(listMatch[1].length / 2);
-                openList(isNumbered ? "ol" : "ul", indent);
-                html += `<li>${lineHtml}</li>`;
-            }
-            else {
-                closeList();
-                html += `<div>${lineHtml}</div>`;
-            }
-        }
-        closeList();
+            let lineResult = null;
+            for (const serializeLineToHtml of serializeSelectionLineToHtmlFns) {
+                lineResult = serializeLineToHtml({
+                    state,
+                    line,
+                    block,
+                    wrapperBlock,
+                    lineText,
+                    startInLine,
+                    endInLine,
+                    lineCursorLength: line.cursorLength,
+                    selectedHtml: lineHtml,
+                });
+                if (lineResult) {
+                    break;
+                }
+            }
+            const group = lineResult?.group ?? null;
+            if (!group || !activeGroup || activeGroup.key !== group.key) {
+                closeGroup();
+                if (group) {
+                    html += group.open;
+                    activeGroup = group;
+                }
+            }
+            html += lineResult?.html ?? `<div>${lineHtml}</div>`;
+        }
+        closeGroup();
         if (!html) {
             return "";
         }