@llui/lexical-loro 0.1.0

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}

package/dist/schema.js

@@ -0,0 +1,363 @@
+/**
+ * The Loro container schema that mirrors a Lexical `EditorState`.
+ *
+ * ── Shape ──────────────────────────────────────────────────────────────────
+ *
+ *   doc.getMap('root')                                 // ElementContainer
+ *     'type'     -> string                             // node.getType()
+ *     'props'    -> LoroMap<Record<string, PropValue>> // node props, LWW per key
+ *     'children' -> LoroMap<uuid, ChildCarrier>        // UNORDERED; see below
+ *
+ * Every child is a CARRIER map, keyed in `children` by its own uuid:
+ *
+ *   ChildCarrier = LoroMap {
+ *     'uuid' -> string                 // its own key, duplicated for reading
+ *     'pos'  -> string                 // fractional index; see `order.ts`
+ *     'kind' -> 'element' | 'text'
+ *     // kind === 'element' — the carrier IS the child's ElementContainer:
+ *     'type' -> string
+ *     'props' -> LoroMap
+ *     'children' -> LoroMap<uuid, ChildCarrier>
+ *     // kind === 'text':
+ *     'text' -> LoroText               // created ONCE, never recreated
+ *   }
+ *
+ * Sibling order is NOT a list position. It is `sort by (pos, uuid)` — a pure
+ * function of replicated state, and therefore commutative by construction.
+ *
+ * ── Why fractional indexing, not a LoroMovableList ─────────────────────────
+ *
+ * This schema previously held children in a `LoroMovableList`, whose `move` op
+ * preserves container identity. That property is load-bearing here: ContainerID
+ * is our stable address for a `NodeKey` (see `mapping.ts`), so a child that is
+ * deleted and recreated instead of moved forces its whole subtree to be rebuilt
+ * with fresh NodeKeys — which DISPOSES every mounted `LLuiDecoratorNode` sub-app
+ * in it (`packages/lexical/src/decorator.ts` disposes on the 'destroyed'
+ * mutation). Block drag-reorder is a real operation in this editor.
+ *
+ * `LoroMovableList` was abandoned because loro-crdt 1.13.7 — the LATEST release,
+ * with no upgrade path — has TWO defects in it, both pinned by
+ * `test/loro-upstream.test.ts`:
+ *
+ *  1. A WASM PANIC. Uncatchable from JavaScript, and it leaves the document in
+ *     an unspecified state, so there is no recovery path to write.
+ *  2. A SILENT CONVERGENCE FAILURE — two peers accept the same updates and
+ *     render different documents, with nothing to detect it from.
+ *
+ * A plain `LoroList` plus uuid identity was evaluated and REJECTED: without a
+ * move op, a reorder is delete+recreate, which silently LOSES a peer's
+ * concurrent edit into the moved subtree. Convergent and unrepairable — strictly
+ * worse than the defects it was meant to route around.
+ *
+ * Fractional indexing keeps the property that mattered. A same-parent move is
+ * ONE last-writer-wins register write to `pos` (~87 bytes regardless of subtree
+ * size): no container is deleted, none is created, and every `ContainerID` —
+ * including every `LoroText` — is INVARIANT across reorder, text edits, and
+ * parent moves. So a concurrent edit into a moved subtree survives, and
+ * `mapping.ts` needs no notion of any of this.
+ *
+ * ── What this deliberately does NOT claim ──────────────────────────────────
+ *
+ * Three documented limits. Do not read the paragraph above as covering them:
+ *
+ *  - CROSS-PARENT moves are still delete+recreate, and DO lose a concurrent edit
+ *    into the moved subtree. The "concurrent edit preserved" property is
+ *    SAME-PARENT ONLY. (This is not a regression: `LoroMovableList#move` is also
+ *    confined to a single list.)
+ *  - DELETE BEATS MOVE. A delete concurrent with a move wins and the block
+ *    vanishes, in both delivery orders. Chosen deliberately: `LoroMovableList`
+ *    does the opposite — it RESURRECTS a deliberately deleted block — and pays
+ *    for it with defect 1 above. A tombstone mitigation was tried and REFUTED BY
+ *    TEST (the delete flag and `pos` are different map keys, so both survive and
+ *    nothing is resurrected). Do not re-add tombstones.
+ *  - TWO CONCURRENT SPLITS of the same text run converge on a child COUNT, not
+ *    on sensible text: ordinal text matching mints a fresh tail container on each
+ *    peer, so the merged document duplicates a fragment. Pre-existing — the
+ *    `LoroMovableList` binding produced the same duplication for the same history
+ *    — and out of scope for the ordering model. Verified against real Lexical;
+ *    see `test/convergence-attack.test.ts` for the concurrent-text histories.
+ *
+ * ── Why one LoroText per RUN, not per TextNode ─────────────────────────────
+ *
+ * A RUN is a MAXIMAL GROUP OF ADJACENT `TextNode`s — not one TextNode. That
+ * distinction is the schema's text unit and it is doing real work: Lexical
+ * splits and merges adjacent TextNodes freely (normalization), and a node
+ * boundary is a rendering detail, not user intent. Mirroring nodes 1:1 would
+ * make every normalization a structural CRDT edit and would let two peers'
+ * different-but-equivalent splits conflict.
+ *
+ * The most common "split" is not a structural change at all: bolding a middle
+ * sub-range makes Lexical split one TextNode into THREE, but all three are
+ * adjacent, so they coalesce back to ONE desired child. The carrier count and
+ * the `LoroText` ContainerID are unchanged and the format lands as a mark inside
+ * the existing text. Verified against real Lexical 0.48 by the D1 case in
+ * `test/to-loro.test.ts` ('run identity under Lexical normalization').
+ *
+ * ── Index units ────────────────────────────────────────────────────────────
+ *
+ * loro-crdt's JavaScript binding addresses `LoroText` in UTF-16 code units —
+ * the same unit as JavaScript string indices and therefore the same unit as
+ * Lexical offsets. NO conversion is required at this seam. (`convertPos` exists
+ * for unicode/utf8 interop; we never need it.) This is pinned by a test in
+ * `test/schema.test.ts` because it is an assumption the whole binding rests on
+ * and it is not stated in loro-crdt's type declarations.
+ */
+import { LoroMap, LoroText, getType } from 'loro-crdt';
+import { comparePositions } from './order.js';
+// ---------------------------------------------------------------------------
+// Container keys
+// ---------------------------------------------------------------------------
+/** Root map name on the `LoroDoc`. Mirrors Lexical's `RootNode`. */
+export const ROOT_CONTAINER = 'root';
+/** Key on an element map holding the Lexical node type (`node.getType()`). */
+export const KEY_TYPE = 'type';
+/** Key on an element map holding the scalar-prop sub-map. */
+export const KEY_PROPS = 'props';
+/** Key on an element map holding the child-carrier map. */
+export const KEY_CHILDREN = 'children';
+/**
+ * Key on a child carrier holding its own uuid.
+ *
+ * Duplicated from the `children` map key so a carrier read in isolation still
+ * knows its identity, and so the ordering tiebreak needs no parent lookup.
+ */
+export const KEY_UUID = 'uuid';
+/** Key on a child carrier holding its fractional index. See `order.ts`. */
+export const KEY_POS = 'pos';
+/**
+ * Key on a child carrier discriminating an element from a text run.
+ *
+ * Explicit rather than inferred from which other keys are present: a remote
+ * update can be applied partially, and a carrier whose `type` has not landed yet
+ * must be SKIPPED by the projection, not mistaken for a text run.
+ */
+export const KEY_KIND = 'kind';
+/** Key on a TEXT carrier holding its `LoroText`. */
+export const KEY_TEXT = 'text';
+/**
+ * `type` value used for an `LLuiDecoratorNode`. Its identity lives in
+ * `props.bridgeType`; its serialized payload in `props.data`.
+ */
+export const DECORATOR_TYPE = 'llui-decorator';
+/** `props` key naming which LLui bridge renders a decorator. */
+export const KEY_BRIDGE_TYPE = 'bridgeType';
+/** `props` key holding a decorator's JSON-serialized payload. */
+export const KEY_DATA = 'data';
+/**
+ * The `expand` rule applied UNIFORMLY to every text format.
+ *
+ * Read `test/expand-semantics.test.ts` before changing this. `expand` is NOT
+ * the mechanism that reproduces Lexical's boundary behaviour — a 51-test spike
+ * proved no uniform table can, and that no per-format table can either (the
+ * divergence set is identical for all 11 formats, because Lexical has no
+ * per-format inclusivity: its caret is uniformly left-biased). The Lexical→Loro
+ * direction replays RESULTING NODE STATE via explicit mark/unmark ops instead
+ * (see `diffRunFormats` in `text.ts`), which makes the local result correct
+ * regardless of `expand`.
+ *
+ * `expand` therefore governs exactly one thing: what happens to text a REMOTE
+ * peer inserts CONCURRENTLY at a mark boundary. `'after'` is the closest fit to
+ * Lexical's left-biased caret.
+ */
+export const TEXT_MARK_EXPAND = 'after';
+// ---------------------------------------------------------------------------
+// Construction + access
+// ---------------------------------------------------------------------------
+/** The Lexical node type of the root. Matches `RootNode.getType()`. */
+export const ROOT_TYPE = 'root';
+/**
+ * Configure a `LoroDoc` for this schema and return its root element container,
+ * creating the root's schema keys if they are missing.
+ *
+ * Every peer MUST call this. Two reasons, both load-bearing:
+ *
+ * 1. `configTextStyle` is LOCAL configuration, not replicated state. A peer that
+ *    skips it resolves marks under different expand rules and diverges.
+ * 2. The root's `props`/`children` are created with `ensureMergeable*`, which
+ *    derives a DETERMINISTIC ContainerID from the parent and key. Two peers may
+ *    each initialize an empty document before ever hearing from one another; a
+ *    plain `setContainer` would mint two different child containers and the map
+ *    slot's last-writer-wins would silently discard one peer's entire document.
+ *    `ensureMergeable*` makes both peers land on the same container, so their
+ *    edits merge. (Only the ROOT needs this — every other element is created
+ *    whole by a single peer and inserted as one op.)
+ */
+export function initDoc(doc, formats) {
+    doc.configTextStyle(Object.fromEntries(formats.map((format) => [format, { expand: TEXT_MARK_EXPAND }])));
+    const root = doc.getMap(ROOT_CONTAINER);
+    // Write only what is missing. `initDoc` runs on every binding construction —
+    // and a shared `LoroDoc` may back more than one — so an unconditional `set`
+    // would queue a redundant local op that the next `import`/`commit` flushes to
+    // every peer as a spurious update.
+    if (root.get(KEY_TYPE) !== ROOT_TYPE)
+        root.set(KEY_TYPE, ROOT_TYPE);
+    root.ensureMergeableMap(KEY_PROPS);
+    root.ensureMergeableMap(KEY_CHILDREN);
+    return root;
+}
+/**
+ * A fresh child identity.
+ *
+ * MUST be random. Two peers minting the same uuid would collide on one slot of
+ * the `children` map, whose last-writer-wins would silently discard a whole
+ * block — the same class of data loss `initDoc`'s `ensureMergeable*` exists to
+ * prevent for the root.
+ */
+export function newUuid() {
+    return crypto.randomUUID();
+}
+/**
+ * Create an element child inside `children` and return its ATTACHED container.
+ *
+ * The carrier IS the element container: an element needs a `pos` anyway, so
+ * wrapping it in a second map would cost an extra container and an extra
+ * dereference for nothing. Only the attached handle has a stable `ContainerID`,
+ * so always take identity from what this returns.
+ */
+export function createElementChild(children, uuid, pos, type) {
+    const element = children.setContainer(uuid, new LoroMap());
+    element.set(KEY_UUID, uuid);
+    element.set(KEY_POS, pos);
+    element.set(KEY_KIND, 'element');
+    element.set(KEY_TYPE, type);
+    element.setContainer(KEY_PROPS, new LoroMap());
+    element.setContainer(KEY_CHILDREN, new LoroMap());
+    return element;
+}
+/**
+ * Create a text child inside `children` and return its ATTACHED `LoroText`.
+ *
+ * The `LoroText` is created once, inside its carrier, and never moved or
+ * recreated — which is precisely what makes its `ContainerID` invariant across
+ * every reorder, and therefore what lets a peer's concurrent insertion into it
+ * survive a block move.
+ */
+export function createTextChild(children, uuid, pos) {
+    const carrier = children.setContainer(uuid, new LoroMap());
+    carrier.set(KEY_UUID, uuid);
+    carrier.set(KEY_POS, pos);
+    carrier.set(KEY_KIND, 'text');
+    return carrier.setContainer(KEY_TEXT, new LoroText());
+}
+/** Re-position a child — the whole cost of a same-parent move. */
+export function setChildPosition(carrier, pos) {
+    carrier.set(KEY_POS, pos);
+}
+/** Remove a child from its parent, container and all. */
+export function deleteChild(children, uuid) {
+    children.delete(uuid);
+}
+/**
+ * An element's children in RENDERED order: sorted by `(pos, uuid)`.
+ *
+ * Malformed carriers are SKIPPED rather than thrown on. That is not defensive
+ * padding: a remote update can be applied while a carrier's keys are still
+ * arriving, and a partially-materialized child must not crash a render — it will
+ * appear on the next event, once its `pos` and `kind` have landed.
+ *
+ * Nothing here consults `isDeleted()`, and nothing may. Projection must depend
+ * ONLY on replicated state; a deleted carrier is simply absent from `keys()` on
+ * every peer, which is what makes this a pure function of the document.
+ */
+export function orderedChildren(element) {
+    const children = elementChildren(element);
+    const out = [];
+    for (const uuid of children.keys()) {
+        // Read as `unknown` and narrow by `instanceof`: the map's declared value
+        // type is a PROMISE about well-formed carriers, and this function's whole
+        // job is to hold that promise against a document that may not keep it yet.
+        const carrier = children.get(uuid);
+        if (!(carrier instanceof LoroMap))
+            continue;
+        const pos = carrier.get(KEY_POS);
+        const kind = carrier.get(KEY_KIND);
+        if (typeof pos !== 'string')
+            continue;
+        if (kind === 'text') {
+            const text = carrier.get(KEY_TEXT);
+            if (!(text instanceof LoroText))
+                continue;
+            out.push({ uuid, pos, kind, carrier: carrier, container: text });
+        }
+        else if (kind === 'element') {
+            const container = carrier;
+            if (typeof container.get(KEY_TYPE) !== 'string')
+                continue;
+            out.push({ uuid, pos, kind, carrier: carrier, container });
+        }
+    }
+    return out.sort((x, y) => comparePositions(x.pos, x.uuid, y.pos, y.uuid));
+}
+/** How many well-formed children an element has. */
+export function childCount(element) {
+    return orderedChildren(element).length;
+}
+/** Read an element's Lexical node type. */
+export function elementType(element) {
+    const type = element.get(KEY_TYPE);
+    if (typeof type !== 'string') {
+        throw new Error(`lexical-loro: element ${element.id} has no '${KEY_TYPE}' string`);
+    }
+    return type;
+}
+/** Read an element's scalar-prop map. */
+export function elementProps(element) {
+    const props = element.get(KEY_PROPS);
+    if (!(props instanceof LoroMap)) {
+        throw new Error(`lexical-loro: element ${element.id} has no '${KEY_PROPS}' map`);
+    }
+    return props;
+}
+/** Read an element's child-carrier map. UNORDERED — see {@link orderedChildren}. */
+export function elementChildren(element) {
+    const children = element.get(KEY_CHILDREN);
+    if (!(children instanceof LoroMap)) {
+        throw new Error(`lexical-loro: element ${element.id} has no '${KEY_CHILDREN}' map`);
+    }
+    return children;
+}
+/** Narrow a child slot to an element container. */
+export function isElementContainer(child) {
+    return child instanceof LoroMap;
+}
+/** Narrow a child slot to a text run. */
+export function isTextContainer(child) {
+    return child instanceof LoroText;
+}
+/** True when this element mirrors an `LLuiDecoratorNode`. */
+export function isDecoratorElement(element) {
+    return elementType(element) === DECORATOR_TYPE;
+}
+/**
+ * Whether a container still exists in the document.
+ *
+ * `getContainerById` keeps returning a usable handle for a DELETED container, so
+ * `isDeleted()` is the real test. The kind narrowing is not defensive padding:
+ * `Container` includes `LoroCounter`, `LoroList` and `LoroTree`, which this
+ * schema never uses, and only its two kinds may enter the registry.
+ *
+ * This is a LOCAL liveness question — "is the registry entry stale?" — not a
+ * projection question. See {@link orderedChildren}.
+ */
+export function containerIsLive(doc, id) {
+    const container = doc.getContainerById(id);
+    if (container instanceof LoroMap)
+        return !container.isDeleted();
+    if (container instanceof LoroText)
+        return !container.isDeleted();
+    return false;
+}
+/**
+ * The `ContainerID` of an attached container — the STABLE, cross-peer address
+ * this binding maps to a per-session `NodeKey`. Throws on a detached container,
+ * which has no replicated identity and must never enter the mapping.
+ */
+export function containerId(container) {
+    const attached = container.getAttached();
+    if (attached === undefined) {
+        throw new Error(`lexical-loro: refusing to address a DETACHED ${getType(container)} container — ` +
+            'insert it into its parent first and use the handle the insert returns');
+    }
+    return attached.id;
+}
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}

package/dist/seed.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Boot: seed an empty shared document, or adopt a populated one.
+ *
+ * This is the shortest file in the package and the one with the most damaging
+ * failure mode. Getting the branch backwards means the SECOND peer to open a
+ * document "seeds" it — writing its local default over content everyone else is
+ * already editing. So the decision is made against the SHARED document's own
+ * emptiness, never against the local editor's, and both orders are pinned by
+ * tests (`test/seed.test.ts`).
+ *
+ * ── Why the seed suppresses the outbound listener ──────────────────────────
+ *
+ * The seed runs as a Lexical update, which would ordinarily be mirrored by the
+ * registered outbound listener. It is tagged `COLLABORATION_TAG` so that does
+ * NOT happen, and `seedLoroFromLexical` writes the shared document explicitly
+ * instead. One write path rather than two means the seed cannot half-land if the
+ * binding's listener registration order ever changes, and the mapping is
+ * populated by the same walk that writes the containers.
+ *
+ * ── Concurrent seeding ─────────────────────────────────────────────────────
+ *
+ * Two peers can each find the shared document empty before hearing from one
+ * another. Nothing can arbitrate that without a coordinator, so the requirement
+ * is CONVERGENCE, not deduplication: both seeds merge and every peer ends up
+ * with both blocks. `initDoc`'s `ensureMergeable*` root containers are what make
+ * that merge possible — with a plain `setContainer` the map slot's
+ * last-writer-wins would silently discard one peer's entire document. Apps that
+ * need exactly one bootstrapper should elect one and pass `shouldBootstrap`
+ * accordingly.
+ */
+import { type LexicalEditor } from 'lexical';
+import type { LoroDoc } from 'loro-crdt';
+import type { ContainerNodeMap } from './mapping.js';
+import { type ElementContainer } from './schema.js';
+/** What {@link bootstrapDocument} did. */
+export type BootstrapOutcome = 
+/** The shared document was empty and this peer filled it from `seed`. */
+'seeded'
+/** The shared document had content; the editor now mirrors it. */
+ | 'adopted'
+/** Empty document, but this peer is not allowed to bootstrap it. */
+ | 'waiting';
+export interface BootstrapTarget {
+    readonly doc: LoroDoc;
+    /** The root element container, as returned by `initDoc`. */
+    readonly root: ElementContainer;
+    readonly mapping: ContainerNodeMap;
+    readonly editor: LexicalEditor;
+    /**
+     * Fill an EMPTY editor with this peer's default content. Runs inside a Lexical
+     * update, at most once, and only when the shared document is empty.
+     */
+    readonly seed?: ((editor: LexicalEditor) => void) | undefined;
+    /**
+     * Whether this peer may bootstrap an empty shared document. Default `true`.
+     * Set `false` on peers that join rather than create — with a real transport,
+     * "empty" before the first sync is indistinguishable from "genuinely empty",
+     * and a joining peer that seeds races the document it was about to receive.
+     */
+    readonly shouldBootstrap?: boolean | undefined;
+}
+/** Whether the shared document holds any content at all. */
+export declare function isSharedDocumentEmpty(root: ElementContainer): boolean;
+/**
+ * Bring the editor and the shared document into agreement at boot.
+ *
+ * Idempotent: calling it again on a populated document adopts (writing nothing
+ * and churning no NodeKeys), so a binding may safely call it on every sync
+ * event without tracking whether it already ran.
+ */
+export declare function bootstrapDocument(target: BootstrapTarget): BootstrapOutcome;
+//# sourceMappingURL=seed.d.ts.map

package/dist/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAkD,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAExC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAc,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAI/D,0CAA0C;AAC1C,MAAM,MAAM,gBAAgB;AAC1B,yEAAyE;AACvE,QAAQ;AACV,kEAAkE;GAChE,SAAS;AACX,oEAAoE;GAClE,SAAS,CAAA;AAEb,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAA;IAClC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;IAC9B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAC7D;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC/C;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAErE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,CA+B3E"}

package/dist/seed.js

@@ -0,0 +1,72 @@
+/**
+ * Boot: seed an empty shared document, or adopt a populated one.
+ *
+ * This is the shortest file in the package and the one with the most damaging
+ * failure mode. Getting the branch backwards means the SECOND peer to open a
+ * document "seeds" it — writing its local default over content everyone else is
+ * already editing. So the decision is made against the SHARED document's own
+ * emptiness, never against the local editor's, and both orders are pinned by
+ * tests (`test/seed.test.ts`).
+ *
+ * ── Why the seed suppresses the outbound listener ──────────────────────────
+ *
+ * The seed runs as a Lexical update, which would ordinarily be mirrored by the
+ * registered outbound listener. It is tagged `COLLABORATION_TAG` so that does
+ * NOT happen, and `seedLoroFromLexical` writes the shared document explicitly
+ * instead. One write path rather than two means the seed cannot half-land if the
+ * binding's listener registration order ever changes, and the mapping is
+ * populated by the same walk that writes the containers.
+ *
+ * ── Concurrent seeding ─────────────────────────────────────────────────────
+ *
+ * Two peers can each find the shared document empty before hearing from one
+ * another. Nothing can arbitrate that without a coordinator, so the requirement
+ * is CONVERGENCE, not deduplication: both seeds merge and every peer ends up
+ * with both blocks. `initDoc`'s `ensureMergeable*` root containers are what make
+ * that merge possible — with a plain `setContainer` the map slot's
+ * last-writer-wins would silently discard one peer's entire document. Apps that
+ * need exactly one bootstrapper should elect one and pass `shouldBootstrap`
+ * accordingly.
+ */
+import { $getRoot, COLLABORATION_TAG, HISTORY_MERGE_TAG } from 'lexical';
+import { childCount } from './schema.js';
+import { adoptLoroDocument } from './to-lexical.js';
+import { seedLoroFromLexical } from './to-loro.js';
+/** Whether the shared document holds any content at all. */
+export function isSharedDocumentEmpty(root) {
+    return childCount(root) === 0;
+}
+/**
+ * Bring the editor and the shared document into agreement at boot.
+ *
+ * Idempotent: calling it again on a populated document adopts (writing nothing
+ * and churning no NodeKeys), so a binding may safely call it on every sync
+ * event without tracking whether it already ran.
+ */
+export function bootstrapDocument(target) {
+    if (!isSharedDocumentEmpty(target.root)) {
+        adoptLoroDocument(target);
+        return 'adopted';
+    }
+    if (target.shouldBootstrap === false)
+        return 'waiting';
+    const seed = target.seed;
+    if (seed !== undefined) {
+        target.editor.update(() => {
+            // Only fill a genuinely empty editor: a remount over a live editor must
+            // not have its content replaced by the default.
+            if (!$getRoot().isEmpty())
+                return;
+            seed(target.editor);
+        }, {
+            // Suppress the outbound listener — the shared document is written below,
+            // by one explicit path. `HISTORY_MERGE_TAG` keeps the seed out of the
+            // user's undo stack, so the first Cmd+Z cannot empty the document.
+            tag: [COLLABORATION_TAG, HISTORY_MERGE_TAG],
+            discrete: true,
+        });
+    }
+    seedLoroFromLexical({ doc: target.doc, root: target.root, mapping: target.mapping }, target.editor.getEditorState());
+    return 'seeded';
+}
+//# sourceMappingURL=seed.js.map

package/dist/seed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.js","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,iBAAiB,EAAsB,MAAM,SAAS,CAAA;AAI5F,OAAO,EAAE,UAAU,EAAyB,MAAM,aAAa,CAAA;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AA+BlD,4DAA4D;AAC5D,MAAM,UAAU,qBAAqB,CAAC,IAAsB;IAC1D,OAAO,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AAC/B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAuB;IACvD,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,iBAAiB,CAAC,MAAM,CAAC,CAAA;QACzB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,IAAI,MAAM,CAAC,eAAe,KAAK,KAAK;QAAE,OAAO,SAAS,CAAA;IAEtD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;IACxB,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,MAAM,CAAC,MAAM,CAAC,MAAM,CAClB,GAAG,EAAE;YACH,wEAAwE;YACxE,gDAAgD;YAChD,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE;gBAAE,OAAM;YACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QACrB,CAAC,EACD;YACE,yEAAyE;YACzE,sEAAsE;YACtE,mEAAmE;YACnE,GAAG,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;YAC3C,QAAQ,EAAE,IAAI;SACf,CACF,CAAA;IACH,CAAC;IAED,mBAAmB,CACjB,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,EAC/D,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,CAC/B,CAAA;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC"}