@agent-native/toolkit 0.23.1 → 0.198.2

package/dist/editor/useCollabReconcile.concurrent.spec.js

@@ -1,2062 +0,0 @@
-// @vitest-environment happy-dom
-import { Editor as CoreEditor } from "@tiptap/core";
-import { useEditor } from "@tiptap/react";
-import React, { act } from "react";
-import { createRoot } from "react-dom/client";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { Awareness } from "y-protocols/awareness";
-import * as Y from "yjs";
-import { createRichMarkdownExtensions } from "./RichMarkdownEditor.js";
-import { useCollabReconcile, getEditorMarkdown } from "./useCollabReconcile.js";
-let container;
-let root;
-beforeEach(() => {
-    globalThis.IS_REACT_ACT_ENVIRONMENT = true;
-    container = document.createElement("div");
-    document.body.appendChild(container);
-    root = createRoot(container);
-});
-afterEach(() => {
-    act(() => root.unmount());
-    vi.useRealTimers();
-    container.remove();
-});
-function makeHarness() {
-    const captured = { editor: null, emitted: [], setContentCalls: 0 };
-    function Harness({ value, contentUpdatedAt, contentRevision, compareContentRevisions, acknowledgedLocalSnapshot, editorOwnedFocus = false, isEditorFocused, }) {
-        const guardsRef = React.useRef(null);
-        const editor = useEditor({
-            extensions: createRichMarkdownExtensions({ dialect: "gfm" }),
-            content: value,
-            onUpdate: ({ editor, transaction }) => {
-                const guards = guardsRef.current;
-                if (!guards || guards.shouldIgnoreUpdate(transaction))
-                    return;
-                const markdown = getEditorMarkdown(editor);
-                if (!guards.registerEmitted(markdown))
-                    return;
-                captured.emitted.push(markdown);
-            },
-        });
-        captured.editor = editor;
-        const guards = useCollabReconcile({
-            editor,
-            value,
-            contentUpdatedAt,
-            contentRevision,
-            compareContentRevisions,
-            acknowledgedLocalSnapshot,
-            onBaseAwareReconcile: (result) => {
-                (captured.reconciled ??= []).push({
-                    status: result.status,
-                    content: result.content,
-                });
-            },
-            editable: true,
-            isEditorFocused: isEditorFocused ?? (() => editorOwnedFocus),
-            getMarkdown: getEditorMarkdown,
-            setContent: (ed, v, options) => {
-                captured.setContentCalls += 1;
-                if (options.addToHistory === false) {
-                    ed.chain()
-                        .command(({ tr }) => {
-                        tr.setMeta("addToHistory", false);
-                        return true;
-                    })
-                        .setContent(v, { emitUpdate: options.emitUpdate })
-                        .run();
-                    return;
-                }
-                ed.commands.setContent(v);
-            },
-        });
-        guardsRef.current = guards;
-        captured.registerEmitted = guards.registerEmitted;
-        return React.createElement("div", null);
-    }
-    return { captured, Harness };
-}
-function makeCollabSeedHarness(initialContent = "") {
-    const captured = { editor: null, emitted: [], setContentCalls: 0 };
-    function Harness({ collabSynced, fragmentLength, value = "seeded content", contentRevision, contentUpdatedAt = "2024-01-01T00:00:01.000Z", initialAppliedUpdatedAt, }) {
-        const guardsRef = React.useRef(null);
-        const fragmentLengthRef = React.useRef(fragmentLength);
-        fragmentLengthRef.current = fragmentLength;
-        const fakeYdoc = React.useMemo(() => ({
-            clientID: 1,
-            getXmlFragment: () => ({ length: fragmentLengthRef.current }),
-        }), []);
-        const editor = useEditor({
-            extensions: createRichMarkdownExtensions({ dialect: "gfm" }),
-            content: initialContent,
-            onUpdate: ({ editor, transaction }) => {
-                const guards = guardsRef.current;
-                if (!guards || guards.shouldIgnoreUpdate(transaction))
-                    return;
-                const markdown = getEditorMarkdown(editor);
-                if (!guards.registerEmitted(markdown))
-                    return;
-                captured.emitted.push(markdown);
-            },
-        });
-        captured.editor = editor;
-        const guards = useCollabReconcile({
-            editor,
-            ydoc: fakeYdoc,
-            collabSynced,
-            value,
-            contentUpdatedAt,
-            contentRevision,
-            initialAppliedUpdatedAt,
-            onBaseAwareReconcile: (result) => {
-                (captured.reconciled ??= []).push({
-                    status: result.status,
-                    content: result.content,
-                });
-            },
-            editable: true,
-            getMarkdown: getEditorMarkdown,
-            setContent: (ed, v) => {
-                captured.setContentCalls += 1;
-                ed.commands.setContent(v);
-            },
-        });
-        guardsRef.current = guards;
-        return React.createElement("div", null);
-    }
-    return { captured, Harness };
-}
-async function flush() {
-    await act(async () => {
-        await Promise.resolve();
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        await Promise.resolve();
-    });
-}
-function makePeerReconcileHarness(initialContent = "original body") {
-    const ydoc = new Y.Doc();
-    ydoc.clientID = 2;
-    const seedEditor = new CoreEditor({
-        extensions: createRichMarkdownExtensions({ dialect: "gfm", ydoc }),
-    });
-    seedEditor.commands.setContent(initialContent);
-    seedEditor.destroy();
-    const awareness = new Awareness(ydoc);
-    awareness.getStates().set(3, {
-        user: { name: "Peer" },
-        visible: true,
-        canFlushDocument: true,
-    });
-    const writes = [];
-    const reconciled = [];
-    let editor = null;
-    function Harness({ value = initialContent, revision = "revision-1", callbackVersion = 0, available = true, collabContentRevision, requestCollabSync, baseAware = false, }) {
-        editor = useEditor({
-            extensions: createRichMarkdownExtensions({ dialect: "gfm", ydoc }),
-        });
-        useCollabReconcile({
-            editor: available ? editor : null,
-            ydoc,
-            awareness,
-            collabSynced: true,
-            value,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: revision,
-            collabContentRevision,
-            requestCollabSync,
-            initialAppliedUpdatedAt: null,
-            editable: true,
-            parseValue: baseAware ? undefined : false,
-            onBaseAwareReconcile: baseAware
-                ? (result) => {
-                    reconciled.push(result);
-                }
-                : undefined,
-            getMarkdown: (editorToRead) => getEditorMarkdown(editorToRead),
-            setContent: (editorToWrite, nextValue, options) => {
-                writes.push({ value: nextValue, callbackVersion });
-                editorToWrite.commands.setContent(nextValue, {
-                    emitUpdate: options.emitUpdate,
-                });
-            },
-        });
-        return React.createElement("div", null);
-    }
-    return {
-        Harness,
-        writes,
-        reconciled,
-        awareness,
-        ydoc,
-        editor: () => editor,
-        markdown: () => getEditorMarkdown(editor),
-        dispose: () => {
-            act(() => root.unmount());
-            root = createRoot(container);
-            awareness.destroy();
-            ydoc.destroy();
-        },
-    };
-}
-function makeConnectedEditorHarness(authorLeads) {
-    const docs = [new Y.Doc(), new Y.Doc()];
-    docs[0].clientID = authorLeads ? 1 : 2;
-    docs[1].clientID = authorLeads ? 2 : 1;
-    const awareness = docs.map((doc) => new Awareness(doc));
-    docs.forEach((doc, index) => {
-        doc.on("update", (update, origin) => {
-            if (origin !== "peer")
-                Y.applyUpdate(docs[1 - index], update, "peer");
-        });
-        awareness[index].getStates().set(1, {
-            user: { name: "First editor" },
-            visible: true,
-            canFlushDocument: true,
-        });
-        awareness[index].getStates().set(2, {
-            user: { name: "Second editor" },
-            visible: true,
-            canFlushDocument: true,
-        });
-    });
-    const editors = [null, null];
-    const emitted = [[], []];
-    const reconciled = [];
-    function Probe({ index, ...props }) {
-        const guardsRef = React.useRef(null);
-        const editor = useEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: docs[index],
-            }),
-            onUpdate: ({ editor, transaction }) => {
-                const guards = guardsRef.current;
-                if (!guards || guards.shouldIgnoreUpdate(transaction))
-                    return;
-                const markdown = getEditorMarkdown(editor);
-                if (guards.registerEmitted(markdown))
-                    emitted[index].push(markdown);
-            },
-        });
-        editors[index] = editor;
-        guardsRef.current = useCollabReconcile({
-            editor,
-            ydoc: docs[index],
-            awareness: awareness[index],
-            collabSynced: true,
-            value: props.value,
-            contentUpdatedAt: props.contentUpdatedAt,
-            contentRevision: props.contentRevision,
-            onBaseAwareReconcile: (result) => reconciled.push({ status: result.status, content: result.content }),
-            getMarkdown: (editorToRead) => getEditorMarkdown(editorToRead),
-            initialAppliedUpdatedAt: null,
-            editable: true,
-        });
-        return React.createElement("div");
-    }
-    function Harness(props) {
-        return React.createElement(React.Fragment, null, React.createElement(Probe, { ...props, index: 0 }), React.createElement(Probe, { ...props, index: 1 }));
-    }
-    return {
-        Harness,
-        editors,
-        emitted,
-        reconciled,
-        markdown: () => editors.map((editor) => getEditorMarkdown(editor)),
-        dispose: () => {
-            act(() => root.unmount());
-            root = createRoot(container);
-            awareness.forEach((state) => state.destroy());
-            docs.forEach((doc) => doc.destroy());
-        },
-    };
-}
-function render(root, Harness, props) {
-    act(() => {
-        root.render(React.createElement(Harness, props));
-    });
-}
-describe("useCollabReconcile — concurrent edit / lost-update guards", () => {
-    it("does not seed an empty editor from a collab-backed SQL snapshot", async () => {
-        vi.useFakeTimers();
-        const harness = makePeerReconcileHarness("");
-        const serverDoc = new Y.Doc();
-        Y.applyUpdate(serverDoc, Y.encodeStateAsUpdate(harness.ydoc));
-        const serverEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: serverDoc,
-            }),
-        });
-        serverEditor.commands.insertContentAt(1, "Accepted body");
-        let finishSync;
-        const requestCollabSync = () => new Promise((resolve) => {
-            finishSync = resolve;
-        });
-        try {
-            act(() => root.render(React.createElement(harness.Harness, {
-                value: "Accepted body",
-                revision: "revision-2",
-                collabContentRevision: "revision-2",
-                requestCollabSync,
-            })));
-            await act(async () => vi.advanceTimersByTimeAsync(30000));
-            expect(harness.markdown()).toBe("");
-            expect(harness.writes).toEqual([]);
-            act(() => Y.applyUpdate(harness.ydoc, Y.encodeStateAsUpdate(serverDoc), "remote"));
-            await act(async () => finishSync({ status: "synced" }));
-            expect(harness.markdown()).toBe("Accepted body");
-            expect(harness.writes).toEqual([]);
-        }
-        finally {
-            serverEditor.destroy();
-            serverDoc.destroy();
-            harness.dispose();
-        }
-    });
-    it.each([
-        [false, false],
-        [true, false],
-        [true, true],
-    ])("receives a collab-backed revision exactly once without SQL fallback (local tail: %s, sync failure: %s)", async (localTail, syncFailure) => {
-        vi.useFakeTimers();
-        const baseline = "original body\n\nSecond paragraph.";
-        const harness = makePeerReconcileHarness(baseline);
-        const serverDoc = new Y.Doc();
-        Y.applyUpdate(serverDoc, Y.encodeStateAsUpdate(harness.ydoc));
-        const serverEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: serverDoc,
-            }),
-        });
-        let finishSync;
-        const requestSync = vi.fn(() => new Promise((resolve) => {
-            finishSync = resolve;
-        }));
-        if (syncFailure)
-            requestSync.mockResolvedValueOnce({ status: "failed" });
-        try {
-            act(() => root.render(React.createElement(harness.Harness)));
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            const stateVector = Y.encodeStateVector(harness.ydoc);
-            serverEditor.commands.insertContentAt(1, "Accepted ");
-            if (localTail) {
-                act(() => harness
-                    .editor()
-                    .commands.insertContentAt(harness.editor().state.doc.content.size - 1, " local tail"));
-            }
-            const props = {
-                value: `Accepted ${baseline}`,
-                revision: "revision-2",
-                collabContentRevision: "revision-2",
-                requestCollabSync: requestSync,
-                baseAware: true,
-            };
-            act(() => root.render(React.createElement(harness.Harness, props)));
-            await act(async () => vi.advanceTimersByTimeAsync(30000));
-            act(() => root.render(React.createElement(harness.Harness, {
-                ...props,
-                callbackVersion: 1,
-            })));
-            expect(requestSync).toHaveBeenCalledTimes(syncFailure ? 2 : 1);
-            expect(harness.writes).toEqual([]);
-            expect(harness.markdown()).toBe(localTail ? `${baseline} local tail` : baseline);
-            act(() => Y.applyUpdate(harness.ydoc, Y.encodeStateAsUpdate(serverDoc, stateVector), "remote"));
-            await act(async () => vi.advanceTimersByTimeAsync(30000));
-            expect(harness.markdown()).toBe(`Accepted ${baseline}${localTail ? " local tail" : ""}`);
-            expect(harness.writes).toEqual([]);
-            // A partial cache update can retain the old marker; a different body
-            // token must still take the ordinary SQL reconciliation path.
-            act(() => root.render(React.createElement(harness.Harness, {
-                ...props,
-                value: `Revised ${baseline}`,
-                revision: "revision-3",
-            })));
-            await act(async () => vi.advanceTimersByTimeAsync(3000));
-            expect(harness.writes).toEqual([]);
-            expect(harness.reconciled).toEqual([]);
-            expect(harness.markdown()).toBe(`Accepted ${baseline}${localTail ? " local tail" : ""}`);
-            await act(async () => finishSync({ status: "synced" }));
-            await act(async () => vi.advanceTimersByTimeAsync(3000));
-            expect(harness.markdown()).toBe(`Revised ${baseline}${localTail ? " local tail" : ""}`);
-            if (localTail)
-                expect(harness.reconciled).toEqual([
-                    expect.objectContaining({
-                        status: "merged",
-                        baseRevision: "revision-2",
-                    }),
-                ]);
-        }
-        finally {
-            serverEditor.destroy();
-            serverDoc.destroy();
-            harness.dispose();
-        }
-    });
-    it.each([true, false])("preserves ordinary mark removal before SQL catches up (author leads: %s)", async (authorLeads) => {
-        const harness = makeConnectedEditorHarness(authorLeads);
-        const baseline = "***Bold*** sample.";
-        const props = {
-            value: baseline,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        };
-        vi.useFakeTimers();
-        try {
-            render(root, harness.Harness, props);
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            expect(harness.markdown()).toEqual([baseline, baseline]);
-            act(() => {
-                harness.editors[0].chain()
-                    .setTextSelection({ from: 1, to: 5 })
-                    .toggleItalic()
-                    .run();
-            });
-            expect(harness.markdown()).toEqual([
-                "**Bold** sample.",
-                "**Bold** sample.",
-            ]);
-            expect(harness.emitted).toEqual([["**Bold** sample."], []]);
-            render(root, harness.Harness, props);
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            expect(harness.markdown()).toEqual([
-                "**Bold** sample.",
-                "**Bold** sample.",
-            ]);
-            expect(harness.emitted).toEqual([["**Bold** sample."], []]);
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it.each([false, true])("merges newer authority after a remote mark change (timestamp ties: %s)", async (timestampTies) => {
-        const harness = makeConnectedEditorHarness(false);
-        const baseline = "***Bold*** sample.\n\nSecond line.";
-        const props = {
-            value: baseline,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        };
-        vi.useFakeTimers();
-        try {
-            render(root, harness.Harness, props);
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            act(() => {
-                harness.editors[0].chain()
-                    .setTextSelection({ from: 1, to: 5 })
-                    .toggleItalic()
-                    .run();
-            });
-            render(root, harness.Harness, {
-                value: "***Bold*** sample.\n\nServer line.",
-                contentUpdatedAt: timestampTies
-                    ? props.contentUpdatedAt
-                    : "2024-01-01T00:00:02.000Z",
-                contentRevision: "revision-2",
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(2501));
-            expect(harness.markdown()).toEqual([
-                "**Bold** sample.\n\nServer line.",
-                "**Bold** sample.\n\nServer line.",
-            ]);
-            expect(harness.reconciled).toEqual([
-                { status: "merged", content: "**Bold** sample.\n\nServer line." },
-            ]);
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it("does not replay sequential SQL acknowledgements over two-tab Yjs edits", async () => {
-        const harness = makeConnectedEditorHarness(false);
-        const baseline = "Alpha\n\nBravo";
-        const firstSave = "Alpha\n\nBravo from first tab";
-        const merged = "Second tab Alpha\n\nBravo from first tab";
-        vi.useFakeTimers();
-        try {
-            render(root, harness.Harness, {
-                value: baseline,
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                contentRevision: "revision-1",
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            act(() => harness.editors[0].commands.setContent(firstSave));
-            act(() => harness.editors[1].commands.setContent(merged));
-            expect(harness.markdown()).toEqual([merged, merged]);
-            render(root, harness.Harness, {
-                value: firstSave,
-                contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-                contentRevision: "revision-2",
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(2501));
-            render(root, harness.Harness, {
-                value: merged,
-                contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-                contentRevision: "revision-3",
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(2501));
-            expect(harness.markdown()).toEqual([merged, merged]);
-            expect(harness.markdown()[0].match(/Second tab Alpha/g)).toHaveLength(1);
-            expect(harness.markdown()[0].match(/Bravo from first tab/g)).toHaveLength(1);
-            expect(harness.reconciled).toEqual([
-                { status: "merged", content: merged },
-            ]);
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it("uses the latest callback at the original peer deadline, including the default normalizer", async () => {
-        const harness = makePeerReconcileHarness();
-        vi.useFakeTimers();
-        try {
-            act(() => root.render(React.createElement(harness.Harness)));
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            for (let callbackVersion = 1; callbackVersion <= 5; callbackVersion += 1) {
-                act(() => root.render(React.createElement(harness.Harness, {
-                    value: "accepted body",
-                    revision: "revision-2",
-                    callbackVersion,
-                })));
-                await act(async () => vi.advanceTimersByTimeAsync(500));
-            }
-            await act(async () => vi.advanceTimersByTimeAsync(1));
-            expect(harness.writes).toEqual([
-                { value: "accepted body", callbackVersion: 5 },
-            ]);
-            expect(harness.markdown()).toBe("accepted body");
-            await act(async () => vi.advanceTimersByTimeAsync(5000));
-            expect(harness.writes).toHaveLength(1);
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it("cancels an obsolete snapshot and starts the peer window for a newer revision", async () => {
-        const harness = makePeerReconcileHarness();
-        vi.useFakeTimers();
-        try {
-            act(() => root.render(React.createElement(harness.Harness)));
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            act(() => root.render(React.createElement(harness.Harness, {
-                value: "accepted body",
-                revision: "revision-2",
-                callbackVersion: 1,
-            })));
-            await act(async () => vi.advanceTimersByTimeAsync(2000));
-            act(() => root.render(React.createElement(harness.Harness, {
-                value: "newer body",
-                revision: "revision-3",
-                callbackVersion: 2,
-            })));
-            await act(async () => vi.advanceTimersByTimeAsync(501));
-            expect(harness.writes).toEqual([]);
-            expect(harness.markdown()).toBe("original body");
-            await act(async () => vi.advanceTimersByTimeAsync(2000));
-            expect(harness.writes).toEqual([
-                { value: "newer body", callbackVersion: 2 },
-            ]);
-            expect(harness.markdown()).toBe("newer body");
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it("cancels a peer reconciliation on unmount", async () => {
-        const harness = makePeerReconcileHarness();
-        vi.useFakeTimers();
-        try {
-            act(() => root.render(React.createElement(harness.Harness)));
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            act(() => root.render(React.createElement(harness.Harness, {
-                value: "accepted body",
-                revision: "revision-2",
-            })));
-            await act(async () => vi.advanceTimersByTimeAsync(1000));
-            act(() => root.render(null));
-            await act(async () => vi.advanceTimersByTimeAsync(3000));
-            expect(harness.writes).toEqual([]);
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it("starts a fresh peer window when the same editor returns after being unavailable", async () => {
-        const harness = makePeerReconcileHarness();
-        vi.useFakeTimers();
-        const snapshot = { value: "accepted body", revision: "revision-2" };
-        try {
-            act(() => root.render(React.createElement(harness.Harness)));
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            act(() => root.render(React.createElement(harness.Harness, snapshot)));
-            await act(async () => vi.advanceTimersByTimeAsync(1000));
-            act(() => root.render(React.createElement(harness.Harness, {
-                ...snapshot,
-                available: false,
-            })));
-            await act(async () => vi.advanceTimersByTimeAsync(2000));
-            expect(harness.writes).toEqual([]);
-            act(() => root.render(React.createElement(harness.Harness, snapshot)));
-            await act(async () => vi.advanceTimersByTimeAsync(2499));
-            expect(harness.writes).toEqual([]);
-            await act(async () => vi.advanceTimersByTimeAsync(2));
-            expect(harness.markdown()).toBe("accepted body");
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it("cancels the peer deadline when leadership is lost and waits again after regaining it", async () => {
-        const harness = makePeerReconcileHarness();
-        vi.useFakeTimers();
-        try {
-            act(() => root.render(React.createElement(harness.Harness)));
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            act(() => root.render(React.createElement(harness.Harness, {
-                value: "accepted body",
-                revision: "revision-2",
-            })));
-            await act(async () => vi.advanceTimersByTimeAsync(1000));
-            act(() => {
-                harness.awareness
-                    .getStates()
-                    .set(1, { user: { name: "Lead peer" }, visible: true });
-                harness.awareness.emit("change", [
-                    { added: [1], updated: [], removed: [] },
-                    "remote",
-                ]);
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(3000));
-            expect(harness.writes).toEqual([]);
-            act(() => {
-                harness.awareness.getStates().delete(1);
-                harness.awareness.emit("change", [
-                    { added: [], updated: [], removed: [1] },
-                    "remote",
-                ]);
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(2499));
-            expect(harness.writes).toEqual([]);
-            await act(async () => vi.advanceTimersByTimeAsync(2));
-            expect(harness.markdown()).toBe("accepted body");
-        }
-        finally {
-            harness.dispose();
-        }
-    });
-    it.each([false, true])("adopts an accepted canonical revision during repeated renders (fresh callbacks: %s)", async (freshCallbacks) => {
-        const liveYdoc = new Y.Doc();
-        liveYdoc.clientID = 1;
-        const persistedEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: liveYdoc,
-            }),
-        });
-        persistedEditor.commands.setContent("**Bold** sample");
-        persistedEditor.destroy();
-        const awareness = new Awareness(liveYdoc);
-        awareness.getStates().set(2, {
-            user: { name: "Peer" },
-            visible: true,
-            canFlushDocument: true,
-        });
-        let capturedEditor = null;
-        const stableRead = (editor) => getEditorMarkdown(editor);
-        const normalizeValue = (value) => value;
-        const stableWrite = (editor, value) => {
-            editor.commands.setContent(value);
-        };
-        function Probe({ accepted }) {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({
-                    dialect: "gfm",
-                    ydoc: liveYdoc,
-                }),
-            });
-            capturedEditor = editor;
-            useCollabReconcile({
-                editor,
-                ydoc: liveYdoc,
-                awareness,
-                collabSynced: true,
-                value: accepted ? "**Changed** sample" : "**Bold** sample",
-                contentUpdatedAt: accepted
-                    ? "2024-01-01T00:00:02.000Z"
-                    : "2024-01-01T00:00:01.000Z",
-                editable: true,
-                initialAppliedUpdatedAt: null,
-                normalizeValue,
-                getMarkdown: freshCallbacks
-                    ? (editor) => stableRead(editor)
-                    : stableRead,
-                setContent: freshCallbacks
-                    ? (editor, value) => stableWrite(editor, value)
-                    : stableWrite,
-            });
-            return React.createElement("div", null);
-        }
-        vi.useFakeTimers();
-        try {
-            act(() => root.render(React.createElement(Probe, { accepted: false })));
-            await act(async () => vi.advanceTimersByTimeAsync(30));
-            expect(getEditorMarkdown(capturedEditor)).toBe("**Bold** sample");
-            const originalEditor = capturedEditor;
-            act(() => root.render(React.createElement(Probe, { accepted: true })));
-            for (let renderIndex = 0; renderIndex < 6; renderIndex += 1) {
-                await act(async () => vi.advanceTimersByTimeAsync(500));
-                act(() => root.render(React.createElement(Probe, { accepted: true })));
-            }
-            expect(capturedEditor).toBe(originalEditor);
-            expect(getEditorMarkdown(capturedEditor)).toBe("**Changed** sample");
-        }
-        finally {
-            act(() => root.unmount());
-            root = createRoot(container);
-            awareness.destroy();
-            liveYdoc.destroy();
-        }
-    });
-    it.each([false, true])("acknowledges peer acceptance before a later local edit (arrival during apply: %s)", async (duringApply) => {
-        const { captured, Harness } = makeHarness();
-        const baseline = "Writers review exact changes.\n\nReaders retain context.";
-        const accepted = baseline.replace("exact", "careful");
-        const props = {
-            value: accepted,
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        };
-        render(root, Harness, {
-            value: baseline,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await flush();
-        const deliverPeer = () => {
-            act(() => captured.editor.commands.setContent(accepted, { emitUpdate: false }));
-        };
-        if (!duringApply)
-            deliverPeer();
-        render(root, Harness, props);
-        if (duringApply)
-            deliverPeer();
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe(accepted);
-        expect(captured.reconciled ?? []).toEqual([]);
-        const draft = `${accepted} Peer suffix.`;
-        act(() => captured.editor.commands.setContent(draft));
-        render(root, Harness, props);
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe(draft);
-        expect(captured.reconciled ?? []).toEqual([]);
-    });
-    it("persists a local suffix when SQL acceptance arrives after peer text", async () => {
-        const { captured, Harness } = makeHarness();
-        const baseline = "Writers review precise changes.\n\nReaders retain context. Peer suffix.";
-        const accepted = baseline.replace("precise", "clearse");
-        render(root, Harness, {
-            value: baseline,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await flush();
-        act(() => captured.editor.commands.setContent(accepted, { emitUpdate: false }));
-        const draft = `${accepted} Trace suffix.`;
-        act(() => captured.editor.commands.insertContentAt(captured.editor.state.doc.content.size - 1, " Trace suffix."));
-        const before = captured.editor.state.doc;
-        const props = {
-            value: accepted,
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        };
-        render(root, Harness, props);
-        await flush();
-        expect(captured.editor.state.doc).toBe(before);
-        expect(getEditorMarkdown(captured.editor)).toBe(draft);
-        expect(captured.reconciled).toEqual([{ status: "merged", content: draft }]);
-        render(root, Harness, props);
-        await flush();
-        expect(captured.reconciled).toHaveLength(1);
-    });
-    it("merges a newer non-overlapping revision and reports the combined draft", async () => {
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await flush();
-        act(() => captured.editor.commands.setContent("Alpha local\n\nBravo\n\nCharlie"));
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie server",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        });
-        await flush();
-        expect(captured.reconciled).toEqual([
-            {
-                status: "merged",
-                content: "Alpha local\n\nBravo\n\nCharlie server",
-            },
-        ]);
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha local\n\nBravo\n\nCharlie server");
-    });
-    it("reports an overlap once and preserves the local draft", async () => {
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Alpha\n\nBravo",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await flush();
-        act(() => captured.editor.commands.setContent("Alpha local\n\nBravo"));
-        const newer = {
-            value: "Alpha server\n\nBravo",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        };
-        render(root, Harness, newer);
-        await flush();
-        render(root, Harness, newer);
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha local\n\nBravo");
-        expect(captured.reconciled).toEqual([
-            { status: "conflict", content: "Alpha local\n\nBravo" },
-        ]);
-    });
-    it("adopts an idle successful local-save echo as a base without replaying it", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Alpha",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-            editorOwnedFocus: true,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha partial"));
-        act(() => captured.editor.commands.setContent("Alpha latest"));
-        await act(async () => vi.advanceTimersByTimeAsync(1600));
-        render(root, Harness, {
-            value: "Alpha partial",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-            acknowledgedLocalSnapshot: {
-                value: "Alpha partial",
-                revision: "revision-2",
-                updatedAt: "2024-01-01T00:00:02.000Z",
-                sequence: 1,
-            },
-            editorOwnedFocus: true,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha latest");
-        expect(captured.reconciled).toBeUndefined();
-    });
-    it("reconciles an external revert with distinct revision even when its content matches a prior local emission", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Base",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-            editorOwnedFocus: true,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Earlier local value"));
-        act(() => captured.editor.commands.setContent("Saved local base"));
-        render(root, Harness, {
-            value: "Saved local base",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-            acknowledgedLocalSnapshot: {
-                value: "Saved local base",
-                revision: "revision-2",
-                updatedAt: "2024-01-01T00:00:02.000Z",
-                sequence: 1,
-            },
-            editorOwnedFocus: true,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: "Earlier local value",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-            contentRevision: "revision-3",
-            acknowledgedLocalSnapshot: {
-                value: "Saved local base",
-                revision: "revision-2",
-                updatedAt: "2024-01-01T00:00:02.000Z",
-                sequence: 1,
-            },
-            editorOwnedFocus: true,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Saved local base");
-        await act(async () => vi.advanceTimersByTimeAsync(2200));
-        expect(getEditorMarkdown(captured.editor)).toBe("Earlier local value");
-    });
-    it("merges a genuine remote change against the acknowledged local-save base", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha saved\n\nBravo\n\nCharlie local"));
-        render(root, Harness, {
-            value: "Alpha saved\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-            acknowledgedLocalSnapshot: {
-                value: "Alpha saved\n\nBravo\n\nCharlie",
-                revision: "revision-2",
-                updatedAt: "2024-01-01T00:00:02.000Z",
-                sequence: 1,
-            },
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha saved\n\nBravo\n\nCharlie local");
-        render(root, Harness, {
-            value: "Alpha saved\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-            contentRevision: "revision-3",
-            acknowledgedLocalSnapshot: {
-                value: "Alpha saved\n\nBravo\n\nCharlie",
-                revision: "revision-2",
-                updatedAt: "2024-01-01T00:00:02.000Z",
-                sequence: 1,
-            },
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha saved\n\nBravo server\n\nCharlie local");
-        expect(captured.reconciled).toEqual([
-            {
-                status: "merged",
-                content: "Alpha saved\n\nBravo server\n\nCharlie local",
-            },
-        ]);
-        render(root, Harness, {
-            value: "Alpha saved\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-            acknowledgedLocalSnapshot: {
-                value: "Alpha saved\n\nBravo\n\nCharlie",
-                revision: "revision-2",
-                updatedAt: "2024-01-01T00:00:02.000Z",
-                sequence: 1,
-            },
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha saved\n\nBravo server\n\nCharlie local");
-        render(root, Harness, {
-            value: "Alpha remote\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:04.000Z",
-            contentRevision: "revision-4",
-            acknowledgedLocalSnapshot: {
-                value: "Alpha saved\n\nBravo\n\nCharlie",
-                revision: "revision-2",
-                updatedAt: "2024-01-01T00:00:02.000Z",
-                sequence: 1,
-            },
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha remote\n\nBravo server\n\nCharlie local");
-    });
-    it("does not clear a fresh conflict latch when an older acknowledged revision reappears", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Alpha",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha latest"));
-        const acknowledgedLocalSnapshot = {
-            value: "Alpha saved",
-            revision: "revision-2",
-            updatedAt: "2024-01-01T00:00:02.000Z",
-            sequence: 1,
-        };
-        render(root, Harness, {
-            value: acknowledgedLocalSnapshot.value,
-            contentUpdatedAt: acknowledgedLocalSnapshot.updatedAt,
-            contentRevision: acknowledgedLocalSnapshot.revision,
-            acknowledgedLocalSnapshot,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        const conflictingRemote = {
-            value: "Alpha remote",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-            contentRevision: "revision-3",
-            acknowledgedLocalSnapshot,
-        };
-        render(root, Harness, conflictingRemote);
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(captured.reconciled).toEqual([
-            { status: "conflict", content: "Alpha latest" },
-        ]);
-        render(root, Harness, {
-            value: acknowledgedLocalSnapshot.value,
-            contentUpdatedAt: acknowledgedLocalSnapshot.updatedAt,
-            contentRevision: acknowledgedLocalSnapshot.revision,
-            acknowledgedLocalSnapshot,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, conflictingRemote);
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha latest");
-        expect(captured.reconciled).toEqual([
-            { status: "conflict", content: "Alpha latest" },
-        ]);
-    });
-    it("does not replace an external base with an acknowledgement at the same timestamp", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        const compareContentRevisions = (first, second) => Number(first.split("-")[1]) - Number(second.split("-")[1]);
-        render(root, Harness, {
-            value: "Alpha saved\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-            compareContentRevisions,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha saved\n\nBravo\n\nCharlie local"));
-        render(root, Harness, {
-            value: "Alpha saved\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-3",
-            compareContentRevisions,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha saved\n\nBravo server\n\nCharlie local");
-        const staleAcknowledgement = {
-            value: "Alpha saved\n\nBravo\n\nCharlie",
-            revision: "revision-2",
-            updatedAt: "2024-01-01T00:00:02.000Z",
-            sequence: 1,
-        };
-        render(root, Harness, {
-            value: staleAcknowledgement.value,
-            contentUpdatedAt: staleAcknowledgement.updatedAt,
-            contentRevision: staleAcknowledgement.revision,
-            compareContentRevisions,
-            acknowledgedLocalSnapshot: staleAcknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: "Alpha saved\n\nBravo remote\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-            contentRevision: "revision-4",
-            compareContentRevisions,
-            acknowledgedLocalSnapshot: staleAcknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha saved\n\nBravo remote\n\nCharlie local");
-        expect(captured.reconciled).toEqual([
-            {
-                status: "merged",
-                content: "Alpha saved\n\nBravo server\n\nCharlie local",
-            },
-            {
-                status: "merged",
-                content: "Alpha saved\n\nBravo remote\n\nCharlie local",
-            },
-        ]);
-    });
-    it("restores the prior base when an external revision follows an equal-timestamp acknowledgement", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha local\n\nBravo\n\nCharlie local"));
-        const acknowledgement = {
-            value: "Alpha local\n\nBravo\n\nCharlie",
-            revision: "revision-2",
-            updatedAt: "2024-01-01T00:00:02.000Z",
-            sequence: 1,
-        };
-        render(root, Harness, {
-            value: acknowledgement.value,
-            contentUpdatedAt: acknowledgement.updatedAt,
-            contentRevision: acknowledgement.revision,
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha local\n\nBravo\n\nCharlie local");
-        render(root, Harness, {
-            value: "Alpha external\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: acknowledgement.updatedAt,
-            contentRevision: "revision-3",
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha local\n\nBravo\n\nCharlie local");
-        expect(captured.reconciled).toEqual([
-            {
-                status: "conflict",
-                content: "Alpha local\n\nBravo\n\nCharlie local",
-            },
-        ]);
-    });
-    it("preserves the prior base when an acknowledgement precedes its canonical snapshot", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        const initial = {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        };
-        render(root, Harness, initial);
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha local\n\nBravo\n\nCharlie local"));
-        const acknowledgement = {
-            value: "Alpha local\n\nBravo\n\nCharlie",
-            revision: "revision-2",
-            updatedAt: "2024-01-01T00:00:02.000Z",
-            sequence: 1,
-        };
-        render(root, Harness, {
-            ...initial,
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: "Alpha external\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: acknowledgement.updatedAt,
-            contentRevision: "revision-3",
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha local\n\nBravo\n\nCharlie local");
-        expect(captured.reconciled).toEqual([
-            {
-                status: "conflict",
-                content: "Alpha local\n\nBravo\n\nCharlie local",
-            },
-        ]);
-    });
-    it("ignores a delayed different revision at an accepted timestamp", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha\n\nBravo\n\nCharlie local"));
-        render(root, Harness, {
-            value: "Alpha\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "body:3:sha256:newest",
-            compareContentRevisions: (first, second) => Number(first.split(":")[1]) - Number(second.split(":")[1]),
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha\n\nBravo server\n\nCharlie local");
-        render(root, Harness, {
-            value: "Alpha stale\n\nBravo\n\nCharlie",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "body:2:sha256:delayed",
-            compareContentRevisions: (first, second) => Number(first.split(":")[1]) - Number(second.split(":")[1]),
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha\n\nBravo server\n\nCharlie local");
-        expect(captured.reconciled).toEqual([
-            {
-                status: "merged",
-                content: "Alpha\n\nBravo server\n\nCharlie local",
-            },
-        ]);
-    });
-    it("accepts a newer acknowledgement at an observed timestamp as the merge base", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        const compareContentRevisions = (first, second) => Number(first.split(":")[1]) - Number(second.split(":")[1]);
-        const timestamp = "2024-01-01T00:00:02.000Z";
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: timestamp,
-            contentRevision: "body:1:sha256:initial",
-            compareContentRevisions,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha local\n\nBravo\n\nCharlie local"));
-        const acknowledgement = {
-            value: "Alpha local\n\nBravo\n\nCharlie",
-            revision: "body:2:sha256:acknowledged",
-            updatedAt: timestamp,
-            sequence: 1,
-        };
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: timestamp,
-            contentRevision: "body:1:sha256:initial",
-            compareContentRevisions,
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: "Alpha external\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: timestamp,
-            contentRevision: "body:3:sha256:external",
-            compareContentRevisions,
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha external\n\nBravo server\n\nCharlie local");
-        expect(captured.reconciled?.at(-1)).toEqual({
-            status: "merged",
-            content: "Alpha external\n\nBravo server\n\nCharlie local",
-        });
-    });
-    it("accepts an opaque acknowledgement at an observed timestamp as the merge base", async () => {
-        vi.useFakeTimers();
-        const { captured, Harness } = makeHarness();
-        const timestamp = "2024-01-01T00:00:02.000Z";
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: timestamp,
-            contentRevision: "initial",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => captured.editor.commands.setContent("Alpha local\n\nBravo\n\nCharlie local"));
-        const acknowledgement = {
-            value: "Alpha local\n\nBravo\n\nCharlie",
-            revision: "acknowledged",
-            updatedAt: timestamp,
-            sequence: 1,
-        };
-        render(root, Harness, {
-            value: "Alpha\n\nBravo\n\nCharlie",
-            contentUpdatedAt: timestamp,
-            contentRevision: "initial",
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: "Alpha external\n\nBravo server\n\nCharlie",
-            contentUpdatedAt: timestamp,
-            contentRevision: "external",
-            acknowledgedLocalSnapshot: acknowledgement,
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha external\n\nBravo server\n\nCharlie local");
-        expect(captured.reconciled?.at(-1)).toEqual({
-            status: "merged",
-            content: "Alpha external\n\nBravo server\n\nCharlie local",
-        });
-    });
-    it("persists the first local edit after a synced empty collaborative document", async () => {
-        const captured = {
-            editor: null,
-            emitted: [],
-            setContentCalls: 0,
-        };
-        function EmptyDocumentHarness() {
-            const guardsRef = React.useRef(null);
-            const insertedRef = React.useRef(false);
-            const ydoc = React.useMemo(() => new Y.Doc(), []);
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({ dialect: "gfm", ydoc }),
-                onUpdate: ({ editor, transaction }) => {
-                    const guards = guardsRef.current;
-                    if (!guards || guards.shouldIgnoreUpdate(transaction))
-                        return;
-                    const markdown = getEditorMarkdown(editor);
-                    if (!guards.registerEmitted(markdown))
-                        return;
-                    captured.emitted.push(markdown);
-                },
-            });
-            captured.editor = editor;
-            guardsRef.current = useCollabReconcile({
-                editor,
-                ydoc,
-                collabSynced: true,
-                value: "",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-                getMarkdown: getEditorMarkdown,
-            });
-            React.useLayoutEffect(() => {
-                if (!editor || insertedRef.current)
-                    return;
-                insertedRef.current = true;
-                editor.view.dispatch(editor.state.tr
-                    .insertText("First persisted edit")
-                    .setMeta("uiEvent", "input"));
-            }, [editor]);
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(EmptyDocumentHarness)));
-        await flush();
-        expect(captured.emitted).toContain("First persisted edit");
-    });
-    it("does not seed until initial collab sync has completed", async () => {
-        const { captured, Harness } = makeCollabSeedHarness();
-        act(() => {
-            root.render(React.createElement(Harness, {
-                collabSynced: false,
-                fragmentLength: 0,
-            }));
-        });
-        await flush();
-        expect(captured.setContentCalls).toBe(0);
-        act(() => {
-            root.render(React.createElement(Harness, {
-                collabSynced: true,
-                fragmentLength: 0,
-            }));
-        });
-        await flush();
-        expect(captured.setContentCalls).toBe(1);
-        expect(getEditorMarkdown(captured.editor)).toBe("seeded content");
-    });
-    it("does not seed after initial collab sync reveals existing canonical content", async () => {
-        const { captured, Harness } = makeCollabSeedHarness("seeded content");
-        act(() => {
-            root.render(React.createElement(Harness, {
-                collabSynced: false,
-                fragmentLength: 0,
-            }));
-        });
-        await flush();
-        act(() => {
-            root.render(React.createElement(Harness, {
-                collabSynced: true,
-                fragmentLength: 1,
-            }));
-        });
-        await flush();
-        expect(captured.setContentCalls).toBe(0);
-        expect(getEditorMarkdown(captured.editor)).toBe("seeded content");
-    });
-    it("preserves a registered local collab mark over an older-or-equal controlled snapshot", async () => {
-        const canonical = "[Link](https://example.com/second) sample.";
-        const { captured, Harness } = makeCollabSeedHarness(canonical);
-        const props = {
-            collabSynced: true,
-            fragmentLength: 1,
-            value: canonical,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            initialAppliedUpdatedAt: null,
-        };
-        act(() => root.render(React.createElement(Harness, props)));
-        await act(async () => new Promise((resolve) => setTimeout(resolve, 30)));
-        act(() => {
-            captured
-                .editor.chain()
-                .setTextSelection({ from: 1, to: 5 })
-                .unsetLink()
-                .run();
-        });
-        expect(captured.emitted.at(-1)).toBe("Link sample.");
-        act(() => root.render(React.createElement(Harness, props)));
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("Link sample.");
-        expect(captured.setContentCalls).toBe(0);
-    });
-    it("still applies newer authority after a registered local collab mark", async () => {
-        const canonical = "[Link](https://example.com/second) sample.";
-        const { captured, Harness } = makeCollabSeedHarness(canonical);
-        act(() => root.render(React.createElement(Harness, {
-            collabSynced: true,
-            fragmentLength: 1,
-            value: canonical,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            initialAppliedUpdatedAt: null,
-        })));
-        await act(async () => new Promise((resolve) => setTimeout(resolve, 30)));
-        act(() => {
-            captured.editor.commands.setContent("Link sample.");
-        });
-        expect(captured.emitted.at(-1)).toBe("Link sample.");
-        act(() => root.render(React.createElement(Harness, {
-            collabSynced: true,
-            fragmentLength: 1,
-            value: "[Link](https://example.com/server) sample.",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            initialAppliedUpdatedAt: null,
-        })));
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("[Link](https://example.com/server) sample.");
-    });
-    it("still reconciles a changed authority revision when its timestamp ties", async () => {
-        const canonical = "Alpha\n\nBravo";
-        const { captured, Harness } = makeCollabSeedHarness(canonical);
-        act(() => root.render(React.createElement(Harness, {
-            collabSynced: true,
-            fragmentLength: 1,
-            value: canonical,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-            initialAppliedUpdatedAt: null,
-        })));
-        await act(async () => new Promise((resolve) => setTimeout(resolve, 30)));
-        act(() => {
-            captured.editor.commands.setContent("Alpha local\n\nBravo");
-        });
-        expect(captured.emitted.at(-1)).toBe("Alpha local\n\nBravo");
-        act(() => root.render(React.createElement(Harness, {
-            collabSynced: true,
-            fragmentLength: 1,
-            value: "Alpha\n\nBravo server",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-2",
-            initialAppliedUpdatedAt: null,
-        })));
-        await flush();
-        expect(captured.reconciled).toEqual([
-            {
-                status: "merged",
-                content: "Alpha local\n\nBravo server",
-            },
-        ]);
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha local\n\nBravo server");
-    });
-    it("still clears a stale collab value when there is no local emission", async () => {
-        const { captured, Harness } = makeCollabSeedHarness("stale persisted body");
-        act(() => root.render(React.createElement(Harness, {
-            collabSynced: true,
-            fragmentLength: 1,
-            value: "canonical SQL body",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            initialAppliedUpdatedAt: null,
-        })));
-        expect(getEditorMarkdown(captured.editor)).toBe("stale persisted body");
-        await act(async () => new Promise((resolve) => setTimeout(resolve, 30)));
-        expect(getEditorMarkdown(captured.editor)).toBe("canonical SQL body");
-        expect(captured.emitted).toEqual([]);
-    });
-    it("uses the collaborative seed as the base for a later three-way merge", async () => {
-        const { captured, Harness } = makeCollabSeedHarness();
-        act(() => {
-            root.render(React.createElement(Harness, {
-                collabSynced: true,
-                fragmentLength: 0,
-                value: "Alpha\n\nBravo\n\nCharlie",
-                contentRevision: "revision-1",
-            }));
-        });
-        await flush();
-        act(() => captured.editor.commands.setContent("Alpha local\n\nBravo\n\nCharlie"));
-        act(() => {
-            root.render(React.createElement(Harness, {
-                collabSynced: true,
-                fragmentLength: 1,
-                value: "Alpha\n\nBravo\n\nCharlie server",
-                contentRevision: "revision-2",
-                contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            }));
-        });
-        await flush();
-        expect(captured.reconciled).toEqual([
-            {
-                status: "merged",
-                content: "Alpha local\n\nBravo\n\nCharlie server",
-            },
-        ]);
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha local\n\nBravo\n\nCharlie server");
-    });
-    it("applies a deliberate REVERT to a previously-applied value after a local edit (not swallowed as echo)", async () => {
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "# V1 content",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# V1 content");
-        render(root, Harness, {
-            value: "# V2 content",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# V2 content");
-        render(root, Harness, {
-            value: "# V1 content",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# V1 content");
-    });
-    it("applies a newer authoritative revert that matches a prior mount-time emission", async () => {
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "# V1 content",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-        });
-        await flush();
-        render(root, Harness, {
-            value: "# V2 content",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# V2 content");
-        expect(captured.registerEmitted?.("# V1 content")).toBe(true);
-        render(root, Harness, {
-            value: "# V1 content",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# V1 content");
-    });
-    it("ignores local-looking editor updates until collaborative seeding completes", async () => {
-        const results = [];
-        function Probe() {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({ dialect: "gfm" }),
-                content: "",
-            });
-            const fakeYdoc = { clientID: 1, getXmlFragment: () => ({ length: 0 }) };
-            const guards = useCollabReconcile({
-                editor,
-                ydoc: fakeYdoc,
-                collabSynced: false,
-                value: "authoritative content",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-            });
-            if (editor && results.length === 0) {
-                results.push(guards.shouldIgnoreUpdate(editor.state.tr));
-            }
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(Probe)));
-        await flush();
-        expect(results).toEqual([true]);
-    });
-    it("allows the first user edit after an authoritative empty doc finishes loading", async () => {
-        let shouldIgnoreUpdate = null;
-        let editor = null;
-        function Probe() {
-            editor = useEditor({
-                extensions: createRichMarkdownExtensions({ dialect: "gfm" }),
-                content: "",
-            });
-            const fakeYdoc = { clientID: 1, getXmlFragment: () => ({ length: 0 }) };
-            const guards = useCollabReconcile({
-                editor,
-                ydoc: fakeYdoc,
-                collabSynced: true,
-                value: "",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-            });
-            shouldIgnoreUpdate = guards.shouldIgnoreUpdate;
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(Probe)));
-        expect(editor).not.toBeNull();
-        expect(shouldIgnoreUpdate).not.toBeNull();
-        expect(shouldIgnoreUpdate(editor.state.tr)).toBe(false);
-    });
-    it("refuses to persist an empty doc in collab mode (registerEmitted guard)", async () => {
-        const results = [];
-        function Probe() {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({ dialect: "gfm" }),
-                content: "",
-            });
-            const fakeYdoc = { clientID: 1, getXmlFragment: () => ({ length: 0 }) };
-            const guards = useCollabReconcile({
-                editor,
-                ydoc: fakeYdoc,
-                value: "seeded content",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-            });
-            if (editor && results.length === 0) {
-                results.push(guards.registerEmitted("   "));
-                results.push(guards.registerEmitted("real text"));
-            }
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(Probe)));
-        await flush();
-        expect(results[0]).toBe(false);
-        expect(results[1]).toBe(true);
-    });
-    it("defers collab seed setContent to a cancellable timer task", async () => {
-        const setContentValues = [];
-        function Probe({ value }) {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({ dialect: "gfm" }),
-                content: "",
-            });
-            const fakeYdoc = { clientID: 1, getXmlFragment: () => ({ length: 0 }) };
-            useCollabReconcile({
-                editor,
-                ydoc: fakeYdoc,
-                value,
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-                setContent: (ed, v) => {
-                    setContentValues.push(v);
-                    ed.commands.setContent(v);
-                },
-            });
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(Probe, { value: "first seed" })));
-        expect(setContentValues).toEqual([]);
-        act(() => root.render(React.createElement(Probe, { value: "second seed" })));
-        expect(setContentValues).toEqual([]);
-        await flush();
-        expect(setContentValues).toEqual(["second seed"]);
-    });
-    it("does not seed beside persisted Y.Doc content projected during initial sync", async () => {
-        const persistedYdoc = new Y.Doc();
-        const persistedEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: persistedYdoc,
-            }),
-        });
-        persistedEditor.commands.setContent("persisted collab body");
-        const persistedUpdate = Y.encodeStateAsUpdate(persistedYdoc);
-        persistedEditor.destroy();
-        persistedYdoc.destroy();
-        const liveYdoc = new Y.Doc();
-        const setContentValues = [];
-        let capturedEditor = null;
-        function Probe({ collabSynced }) {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({
-                    dialect: "gfm",
-                    ydoc: liveYdoc,
-                }),
-            });
-            capturedEditor = editor;
-            useCollabReconcile({
-                editor,
-                ydoc: liveYdoc,
-                collabSynced,
-                value: "persisted collab body",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-                setContent: (_editor, nextValue) => {
-                    setContentValues.push(nextValue);
-                },
-            });
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(Probe, { collabSynced: false })));
-        act(() => Y.applyUpdate(liveYdoc, persistedUpdate, "remote"));
-        act(() => root.render(React.createElement(Probe, { collabSynced: true })));
-        await flush();
-        expect(getEditorMarkdown(capturedEditor)).toBe("persisted collab body");
-        expect(setContentValues).toEqual([]);
-        expect(getEditorMarkdown(capturedEditor).match(/persisted collab body/g)).toHaveLength(1);
-        liveYdoc.destroy();
-    });
-    it("adopts a nonempty synced Y.Doc instead of reconciling an empty SQL snapshot", async () => {
-        vi.useFakeTimers();
-        const persistedYdoc = new Y.Doc();
-        const persistedEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: persistedYdoc,
-            }),
-        });
-        persistedEditor.commands.setContent("live collaborator body");
-        const liveYdoc = new Y.Doc();
-        Y.applyUpdate(liveYdoc, Y.encodeStateAsUpdate(persistedYdoc), "remote");
-        persistedEditor.destroy();
-        persistedYdoc.destroy();
-        const awareness = new Awareness(liveYdoc);
-        const setContentValues = [];
-        let capturedEditor = null;
-        function Probe() {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({
-                    dialect: "gfm",
-                    ydoc: liveYdoc,
-                }),
-            });
-            capturedEditor = editor;
-            useCollabReconcile({
-                editor,
-                ydoc: liveYdoc,
-                awareness,
-                collabSynced: true,
-                value: "",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-                setContent: (_editor, nextValue) => {
-                    setContentValues.push(nextValue);
-                },
-            });
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(Probe)));
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        act(() => {
-            awareness.getStates().set(4_294_967_295, {
-                user: { name: "Active peer" },
-                visible: true,
-            });
-            awareness.emit("change", [
-                { added: [4_294_967_295], updated: [], removed: [] },
-                "remote",
-            ]);
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(2500));
-        expect(getEditorMarkdown(capturedEditor)).toBe("live collaborator body");
-        expect(setContentValues).toEqual([]);
-        vi.useRealTimers();
-        awareness.destroy();
-        liveYdoc.destroy();
-    });
-    it("lets canonical empty SQL clear stale persisted Y.Doc content with no active peer", async () => {
-        const persistedYdoc = new Y.Doc();
-        const persistedEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: persistedYdoc,
-            }),
-        });
-        persistedEditor.commands.setContent("stale persisted body");
-        const liveYdoc = new Y.Doc();
-        Y.applyUpdate(liveYdoc, Y.encodeStateAsUpdate(persistedYdoc), "remote");
-        persistedEditor.destroy();
-        persistedYdoc.destroy();
-        const setContentValues = [];
-        let capturedEditor = null;
-        const awareness = new Awareness(liveYdoc);
-        function Probe() {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({
-                    dialect: "gfm",
-                    ydoc: liveYdoc,
-                }),
-            });
-            capturedEditor = editor;
-            useCollabReconcile({
-                editor,
-                ydoc: liveYdoc,
-                awareness,
-                collabSynced: true,
-                value: "",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-                setContent: (editorToClear, nextValue) => {
-                    setContentValues.push(nextValue);
-                    editorToClear.commands.setContent(nextValue);
-                },
-            });
-            return React.createElement("div", null);
-        }
-        vi.useFakeTimers();
-        act(() => root.render(React.createElement(Probe)));
-        await act(async () => vi.advanceTimersByTimeAsync(2499));
-        expect(setContentValues).toEqual([]);
-        await act(async () => vi.advanceTimersByTimeAsync(51));
-        expect(setContentValues).toContain("");
-        expect(getEditorMarkdown(capturedEditor)).toBe("");
-        vi.useRealTimers();
-        awareness.destroy();
-        liveYdoc.destroy();
-    });
-    it("preserves and permits a first local edit during the awareness settle window", async () => {
-        const persistedYdoc = new Y.Doc();
-        const persistedEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: persistedYdoc,
-            }),
-        });
-        persistedEditor.commands.setContent("stale persisted body");
-        const liveYdoc = new Y.Doc();
-        Y.applyUpdate(liveYdoc, Y.encodeStateAsUpdate(persistedYdoc), "remote");
-        persistedEditor.destroy();
-        persistedYdoc.destroy();
-        const awareness = new Awareness(liveYdoc);
-        let capturedEditor = null;
-        let guards = null;
-        const setContentValues = [];
-        function Probe() {
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({
-                    dialect: "gfm",
-                    ydoc: liveYdoc,
-                }),
-            });
-            capturedEditor = editor;
-            guards = useCollabReconcile({
-                editor,
-                ydoc: liveYdoc,
-                awareness,
-                collabSynced: true,
-                value: "",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-                setContent: (editorToSet, nextValue) => {
-                    setContentValues.push(nextValue);
-                    editorToSet.commands.setContent(nextValue);
-                },
-            });
-            return React.createElement("div", null);
-        }
-        vi.useFakeTimers();
-        act(() => root.render(React.createElement(Probe)));
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(guards).not.toBeNull();
-        expect(capturedEditor).not.toBeNull();
-        expect(guards.shouldIgnoreUpdate(capturedEditor.state.tr)).toBe(false);
-        expect(guards.registerEmitted("first local edit")).toBe(true);
-        act(() => capturedEditor.commands.setContent("first local edit"));
-        await act(async () => vi.advanceTimersByTimeAsync(2500));
-        expect(getEditorMarkdown(capturedEditor)).toBe("first local edit");
-        expect(setContentValues).toEqual([]);
-        vi.useRealTimers();
-        awareness.destroy();
-        liveYdoc.destroy();
-    });
-    it("applies a genuinely newer external value once the user is no longer focused", async () => {
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "# Doc",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-        });
-        await flush();
-        act(() => captured.editor.commands.blur());
-        render(root, Harness, {
-            value: "# Doc updated by agent",
-            contentUpdatedAt: "2024-01-01T00:00:05.000Z",
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# Doc updated by agent");
-    });
-    it("merges typing that lands after an external reconcile decision before adopting the save baseline", async () => {
-        const { captured, Harness } = makeHarness();
-        vi.useFakeTimers();
-        const base = "Alpha base.\n\nOmega base.";
-        const external = "Alpha from server.\n\nOmega base.";
-        const initial = {
-            value: base,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        };
-        render(root, Harness, initial);
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: external,
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        });
-        act(() => captured.editor.commands.insertContentAt(base.length, " LOCAL"));
-        render(root, Harness, {
-            value: external,
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        const merged = "Alpha from server.\n\nOmega base LOCAL.";
-        expect(getEditorMarkdown(captured.editor)).toBe(merged);
-        expect(captured.reconciled).toEqual([
-            { status: "merged", content: merged },
-        ]);
-        render(root, Harness, {
-            value: external,
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-            acknowledgedLocalSnapshot: {
-                value: merged,
-                revision: "revision-3",
-                updatedAt: "2024-01-01T00:00:03.000Z",
-                sequence: 1,
-            },
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(5000));
-        expect(getEditorMarkdown(captured.editor)).toBe(merged);
-        expect(captured.reconciled).toHaveLength(1);
-    });
-    it("supersedes a pending decision with the newest revision and preserves later typing", async () => {
-        const { captured, Harness } = makeHarness();
-        vi.useFakeTimers();
-        const base = "Alpha base.\n\nOmega base.";
-        render(root, Harness, {
-            value: base,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: "Alpha revision 2.\n\nOmega base.",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        });
-        render(root, Harness, {
-            value: "Alpha revision 3.\n\nOmega base.",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-            contentRevision: "revision-3",
-        });
-        act(() => captured.editor.commands.insertContentAt(base.length, " LOCAL"));
-        render(root, Harness, {
-            value: "Alpha revision 3.\n\nOmega base.",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-            contentRevision: "revision-3",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha revision 3.\n\nOmega base LOCAL.");
-        expect(captured.reconciled).toEqual([
-            {
-                status: "merged",
-                content: "Alpha revision 3.\n\nOmega base LOCAL.",
-            },
-        ]);
-    });
-    it("reports an overlap after the reconcile decision without replacing local typing", async () => {
-        const { captured, Harness } = makeHarness();
-        vi.useFakeTimers();
-        const base = "Alpha base.\n\nOmega base.";
-        render(root, Harness, {
-            value: base,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            contentRevision: "revision-1",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        render(root, Harness, {
-            value: "Alpha from server.\n\nOmega base.",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        });
-        act(() => captured.editor.commands.setContent("Alpha locally typed.\n\nOmega base."));
-        render(root, Harness, {
-            value: "Alpha from server.\n\nOmega base.",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            contentRevision: "revision-2",
-        });
-        await act(async () => vi.advanceTimersByTimeAsync(0));
-        expect(getEditorMarkdown(captured.editor)).toBe("Alpha locally typed.\n\nOmega base.");
-        expect(captured.reconciled).toEqual([
-            { status: "conflict", content: "Alpha locally typed.\n\nOmega base." },
-        ]);
-    });
-    it("does not roll back a blurred local mark while its controlled echo is queued", async () => {
-        const { captured, Harness } = makeHarness();
-        const canonical = "[Link](https://example.com/first) sample.";
-        let editorFocused = false;
-        const isEditorFocused = () => editorFocused;
-        const props = {
-            value: canonical,
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            isEditorFocused,
-        };
-        render(root, Harness, props);
-        await flush();
-        expect(captured.setContentCalls).toBe(0);
-        act(() => {
-            captured
-                .editor.chain()
-                .setTextSelection({ from: 1, to: 5 })
-                .unsetLink()
-                .run();
-        });
-        const localDraft = captured.emitted.at(-1);
-        expect(localDraft).toBe("Link sample.");
-        render(root, Harness, props);
-        editorFocused = true;
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe(localDraft);
-        expect(captured.setContentCalls).toBe(0);
-        render(root, Harness, { ...props, value: localDraft });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe(localDraft);
-    });
-    it("persists a non-lead client's own local edit to a nonempty shared document", async () => {
-        const persistedYdoc = new Y.Doc();
-        const persistedEditor = new CoreEditor({
-            extensions: createRichMarkdownExtensions({
-                dialect: "gfm",
-                ydoc: persistedYdoc,
-            }),
-        });
-        persistedEditor.commands.setContent("shared body");
-        const liveYdoc = new Y.Doc();
-        Y.applyUpdate(liveYdoc, Y.encodeStateAsUpdate(persistedYdoc), "remote");
-        persistedEditor.destroy();
-        persistedYdoc.destroy();
-        liveYdoc.clientID = 500;
-        const awareness = new Awareness(liveYdoc);
-        awareness
-            .getStates()
-            .set(1, { user: { name: "Lead peer" }, visible: true });
-        const emitted = [];
-        let capturedEditor = null;
-        function Probe() {
-            const guardsRef = React.useRef(null);
-            const editor = useEditor({
-                extensions: createRichMarkdownExtensions({
-                    dialect: "gfm",
-                    ydoc: liveYdoc,
-                }),
-                onUpdate: ({ editor, transaction }) => {
-                    const guards = guardsRef.current;
-                    if (!guards || guards.shouldIgnoreUpdate(transaction))
-                        return;
-                    const markdown = getEditorMarkdown(editor);
-                    if (!guards.registerEmitted(markdown))
-                        return;
-                    emitted.push(markdown);
-                },
-            });
-            capturedEditor = editor;
-            guardsRef.current = useCollabReconcile({
-                editor,
-                ydoc: liveYdoc,
-                awareness,
-                collabSynced: true,
-                value: "shared body",
-                contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-                editable: true,
-            });
-            return React.createElement("div", null);
-        }
-        act(() => root.render(React.createElement(Probe)));
-        await flush();
-        act(() => {
-            capturedEditor.view.dispatch(capturedEditor.state.tr
-                .insertText(" plus my edit", capturedEditor.state.doc.content.size - 1)
-                .setMeta("uiEvent", "input"));
-        });
-        expect(emitted.at(-1)).toContain("plus my edit");
-        awareness.destroy();
-        liveYdoc.destroy();
-    });
-    it("does not reapply a partial save echo while an external editor control owns focus", async () => {
-        const { captured, Harness } = makeHarness();
-        render(root, Harness, {
-            value: "# abcdef",
-            contentUpdatedAt: "2024-01-01T00:00:01.000Z",
-            editorOwnedFocus: true,
-        });
-        await flush();
-        act(() => captured.editor.commands.setContent("# abcde"));
-        act(() => captured.editor.commands.setContent("# ab"));
-        expect(getEditorMarkdown(captured.editor)).toBe("# ab");
-        render(root, Harness, {
-            value: "# abcde",
-            contentUpdatedAt: "2024-01-01T00:00:02.000Z",
-            editorOwnedFocus: true,
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# ab");
-        render(root, Harness, {
-            value: "# updated externally",
-            contentUpdatedAt: "2024-01-01T00:00:03.000Z",
-            editorOwnedFocus: false,
-        });
-        await flush();
-        expect(getEditorMarkdown(captured.editor)).toBe("# updated externally");
-    });
-});
-//# sourceMappingURL=useCollabReconcile.concurrent.spec.js.map