@llui/lexical-loro 0.1.0

package/dist/text.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Text: format-bitmask ↔ named-Loro-mark conversion, the run diff that replays
+ * Lexical's resulting state, and a cursor-biased string diff.
+ *
+ * ── Why formats are DECOMPOSED into named marks ────────────────────────────
+ *
+ * `TextNode.__format` is a bitmask. Storing it as ONE Loro value makes two peers
+ * concurrently toggling bold and italic on overlapping ranges a last-writer-wins
+ * conflict that SILENTLY DROPS one of them. Stored as independent named marks
+ * (`bold`, `italic`, …) the same edit converges to the union. This is measured
+ * in `test/expand-semantics.test.ts` §4, both the working and the broken form.
+ *
+ * The bit values are derived from Lexical's `TEXT_TYPE_TO_FORMAT` at runtime —
+ * never hardcoded, so a Lexical release that renumbers or adds a format is a
+ * compile/boot-time failure here rather than silent corruption.
+ *
+ * ── Why the outbound direction replays STATE, not keystrokes ───────────────
+ *
+ * Loro's `expand` rule cannot reproduce Lexical's boundary behaviour: no uniform
+ * table works, and no PER-FORMAT table can either, because the divergence set is
+ * identical for all 11 formats — Lexical has no per-format inclusivity, its
+ * caret is uniformly left-biased (`LexicalSelection.ts:3164-3204`). Three cases
+ * are unreachable by any table:
+ *
+ *   1. typing at index 0 of a formatted first run
+ *   2. a format toggled ON at a collapsed caret
+ *   3. a format toggled OFF at a collapsed caret
+ *
+ * So after each Lexical update we diff the RESULTING TextNode runs against what
+ * Loro currently holds and emit explicit `mark`/`unmark` ops for every format
+ * bit that differs — {@link diffRunFormats}. `expand` then governs only what
+ * happens to text a REMOTE peer inserts concurrently at a mark boundary.
+ *
+ * ── Index units ────────────────────────────────────────────────────────────
+ *
+ * All offsets here are UTF-16 code units: JavaScript string indices, Lexical
+ * offsets, and loro-crdt's JS text indices all agree (pinned in
+ * `test/schema.test.ts`). No conversion at this seam.
+ */
+import type { LoroText } from 'loro-crdt';
+/**
+ * The Lexical text formats a Loro binding represents, in bit order (see
+ * Lexical's `LexicalConstants.ts`). Each becomes an INDEPENDENT named mark.
+ */
+export declare const LORO_TEXT_FORMATS: readonly ["bold", "italic", "strikethrough", "underline", "code", "subscript", "superscript", "highlight", "lowercase", "uppercase", "capitalize"];
+export type LoroTextFormat = (typeof LORO_TEXT_FORMATS)[number];
+/**
+ * Mark name → bit value, derived from Lexical rather than hardcoded.
+ *
+ * Built eagerly so a format this package names but Lexical does not define
+ * fails at module load — a loud boot error instead of a format that silently
+ * never round-trips.
+ */
+export declare const FORMAT_BITS: Readonly<Record<LoroTextFormat, number>>;
+/** Every bit this binding knows how to represent. */
+export declare const KNOWN_FORMAT_MASK: number;
+/** The bit value of a named format. */
+export declare function formatBit(format: LoroTextFormat): number;
+/** Decompose a Lexical bitmask into the named marks it sets, in bit order. */
+export declare function formatsFromBitmask(bitmask: number): LoroTextFormat[];
+/** Recompose named marks into a Lexical bitmask. */
+export declare function bitmaskFromFormats(formats: Iterable<LoroTextFormat>): number;
+/**
+ * Read a Loro delta's attribute bag as a Lexical bitmask.
+ *
+ * Only `true` counts as set: Loro represents an unmark as an explicit `null`
+ * attribute in the delta, which must read as OFF, not as "present".
+ */
+export declare function bitmaskFromAttributes(attributes: Readonly<Record<string, unknown>> | undefined): number;
+/** A maximal stretch of text sharing one Lexical format bitmask. */
+export interface TextRun {
+    readonly text: string;
+    readonly format: number;
+}
+/** Concatenated text of a run list. */
+export declare function runsText(runs: readonly TextRun[]): string;
+/**
+ * Coalesce adjacent equal-format runs and drop empty ones, so two run lists
+ * describing the same content compare structurally equal.
+ *
+ * Necessary because Lexical's node boundaries are a rendering detail: `ab`+`c`
+ * and `abc` at the same format are the same document.
+ */
+export declare function normalizeRuns(runs: readonly TextRun[]): TextRun[];
+/** A Loro text delta item, as returned by `LoroText#toDelta`. */
+export interface TextDeltaItem {
+    readonly insert?: unknown;
+    readonly attributes?: Readonly<Record<string, unknown>>;
+}
+/** Project a `LoroText`'s delta into normalized Lexical-shaped runs. */
+export declare function runsFromDelta(delta: readonly TextDeltaItem[]): TextRun[];
+/** Project a live `LoroText` into normalized Lexical-shaped runs. */
+export declare function runsFromText(text: LoroText): TextRun[];
+/** An explicit format operation to apply to a `LoroText`. */
+export interface MarkOp {
+    readonly kind: 'mark' | 'unmark';
+    /** Inclusive UTF-16 start offset. */
+    readonly start: number;
+    /** Exclusive UTF-16 end offset. */
+    readonly end: number;
+    readonly format: LoroTextFormat;
+}
+/**
+ * Diff two run lists into the minimal explicit `mark`/`unmark` ops that turn
+ * `current` into `target`.
+ *
+ * `current` is what Loro holds after the text edit landed (so `expand` has
+ * already had its say); `target` is the runs Lexical actually produced. Both
+ * MUST describe the same character count — call this only after the text
+ * content has been reconciled.
+ *
+ * Each format is diffed INDEPENDENTLY (that is the whole point of decomposing
+ * the bitmask) and differing characters are coalesced into maximal ranges, so a
+ * whole-paragraph bolding is one op, not one per character.
+ */
+export declare function diffRunFormats(current: readonly TextRun[], target: readonly TextRun[]): MarkOp[];
+/**
+ * Apply {@link MarkOp}s to a `LoroText`. The caller owns the surrounding
+ * transaction (`doc.commit`), so a whole Lexical update lands as one Loro
+ * change and therefore as one remote event batch.
+ */
+export declare function applyMarkOps(text: LoroText, ops: readonly MarkOp[]): void;
+/** A single-region string edit: delete `remove` chars at `index`, insert `insert`. */
+export interface TextDiff {
+    /** UTF-16 offset at which the change applies. */
+    readonly index: number;
+    /** Number of UTF-16 code units to delete at `index`. */
+    readonly remove: number;
+    /** Text to insert at `index` after the deletion. */
+    readonly insert: string;
+}
+/**
+ * Diff `a` → `b`, biased to place the change at `cursor`.
+ *
+ * A plain "common prefix / common suffix" diff is ambiguous whenever the edit
+ * sits next to repeated characters: typing `o` in `foo` could be described as an
+ * insert at index 1, 2 or 3, and the plain diff always picks the leftmost. Every
+ * peer then sees the character inserted at the wrong place, which drags remote
+ * carets and (through Loro's `expand`) can even attach the wrong formatting.
+ *
+ * Biasing the prefix scan to stop AT the cursor resolves the ambiguity in favour
+ * of where the user actually typed. `@lexical/yjs` uses `simpleDiffWithCursor`
+ * for exactly this reason; this is that algorithm (lib0's
+ * `simpleDiffStringWithCursor`), including its surrogate-pair rollbacks, ported
+ * so the package carries no lib0 dependency.
+ *
+ * Surrogate handling: the scans never stop between the halves of a surrogate
+ * pair, so an astral character is always inserted or deleted whole.
+ *
+ * @param cursor UTF-16 offset of the caret in `b` (the new string).
+ */
+export declare function diffTextWithCursor(a: string, b: string, cursor: number): TextDiff;
+/**
+ * Cursor-free variant: the change is placed as far LEFT as possible.
+ *
+ * Equivalent to lib0's `simpleDiffString`. Use it only where no caret is known
+ * (a programmatic document change); prefer {@link diffTextWithCursor} on any
+ * user-typing path, where the leftmost placement is exactly the wrong guess.
+ */
+export declare function diffText(a: string, b: string): TextDiff;
+/**
+ * Apply a {@link TextDiff} to a `LoroText`. A no-op diff writes nothing, so a
+ * Lexical update that changed only formatting produces no text ops (and so no
+ * spurious remote text event).
+ */
+export declare function applyTextDiff(text: LoroText, diff: TextDiff): void;
+//# sourceMappingURL=text.d.ts.map

package/dist/text.d.ts.map

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

package/dist/text.js

@@ -0,0 +1,289 @@
+/**
+ * Text: format-bitmask ↔ named-Loro-mark conversion, the run diff that replays
+ * Lexical's resulting state, and a cursor-biased string diff.
+ *
+ * ── Why formats are DECOMPOSED into named marks ────────────────────────────
+ *
+ * `TextNode.__format` is a bitmask. Storing it as ONE Loro value makes two peers
+ * concurrently toggling bold and italic on overlapping ranges a last-writer-wins
+ * conflict that SILENTLY DROPS one of them. Stored as independent named marks
+ * (`bold`, `italic`, …) the same edit converges to the union. This is measured
+ * in `test/expand-semantics.test.ts` §4, both the working and the broken form.
+ *
+ * The bit values are derived from Lexical's `TEXT_TYPE_TO_FORMAT` at runtime —
+ * never hardcoded, so a Lexical release that renumbers or adds a format is a
+ * compile/boot-time failure here rather than silent corruption.
+ *
+ * ── Why the outbound direction replays STATE, not keystrokes ───────────────
+ *
+ * Loro's `expand` rule cannot reproduce Lexical's boundary behaviour: no uniform
+ * table works, and no PER-FORMAT table can either, because the divergence set is
+ * identical for all 11 formats — Lexical has no per-format inclusivity, its
+ * caret is uniformly left-biased (`LexicalSelection.ts:3164-3204`). Three cases
+ * are unreachable by any table:
+ *
+ *   1. typing at index 0 of a formatted first run
+ *   2. a format toggled ON at a collapsed caret
+ *   3. a format toggled OFF at a collapsed caret
+ *
+ * So after each Lexical update we diff the RESULTING TextNode runs against what
+ * Loro currently holds and emit explicit `mark`/`unmark` ops for every format
+ * bit that differs — {@link diffRunFormats}. `expand` then governs only what
+ * happens to text a REMOTE peer inserts concurrently at a mark boundary.
+ *
+ * ── Index units ────────────────────────────────────────────────────────────
+ *
+ * All offsets here are UTF-16 code units: JavaScript string indices, Lexical
+ * offsets, and loro-crdt's JS text indices all agree (pinned in
+ * `test/schema.test.ts`). No conversion at this seam.
+ */
+import { TEXT_TYPE_TO_FORMAT } from 'lexical';
+// ---------------------------------------------------------------------------
+// Format vocabulary
+// ---------------------------------------------------------------------------
+/**
+ * The Lexical text formats a Loro binding represents, in bit order (see
+ * Lexical's `LexicalConstants.ts`). Each becomes an INDEPENDENT named mark.
+ */
+export const LORO_TEXT_FORMATS = [
+    'bold',
+    'italic',
+    'strikethrough',
+    'underline',
+    'code',
+    'subscript',
+    'superscript',
+    'highlight',
+    'lowercase',
+    'uppercase',
+    'capitalize',
+];
+/**
+ * Mark name → bit value, derived from Lexical rather than hardcoded.
+ *
+ * Built eagerly so a format this package names but Lexical does not define
+ * fails at module load — a loud boot error instead of a format that silently
+ * never round-trips.
+ */
+export const FORMAT_BITS = Object.freeze(Object.fromEntries(LORO_TEXT_FORMATS.map((format) => {
+    const bit = TEXT_TYPE_TO_FORMAT[format];
+    if (bit === undefined) {
+        throw new Error(`lexical-loro: Lexical does not define the text format '${format}' — ` +
+            'LORO_TEXT_FORMATS is out of sync with TEXT_TYPE_TO_FORMAT');
+    }
+    return [format, bit];
+})));
+/** Every bit this binding knows how to represent. */
+export const KNOWN_FORMAT_MASK = LORO_TEXT_FORMATS.reduce((mask, format) => mask | FORMAT_BITS[format], 0);
+/** The bit value of a named format. */
+export function formatBit(format) {
+    return FORMAT_BITS[format];
+}
+/** Decompose a Lexical bitmask into the named marks it sets, in bit order. */
+export function formatsFromBitmask(bitmask) {
+    return LORO_TEXT_FORMATS.filter((format) => (bitmask & FORMAT_BITS[format]) !== 0);
+}
+/** Recompose named marks into a Lexical bitmask. */
+export function bitmaskFromFormats(formats) {
+    let bitmask = 0;
+    for (const format of formats)
+        bitmask |= FORMAT_BITS[format];
+    return bitmask;
+}
+/**
+ * Read a Loro delta's attribute bag as a Lexical bitmask.
+ *
+ * Only `true` counts as set: Loro represents an unmark as an explicit `null`
+ * attribute in the delta, which must read as OFF, not as "present".
+ */
+export function bitmaskFromAttributes(attributes) {
+    if (attributes === undefined)
+        return 0;
+    let bitmask = 0;
+    for (const format of LORO_TEXT_FORMATS) {
+        if (attributes[format] === true)
+            bitmask |= FORMAT_BITS[format];
+    }
+    return bitmask;
+}
+/** Concatenated text of a run list. */
+export function runsText(runs) {
+    return runs.map((run) => run.text).join('');
+}
+/**
+ * Coalesce adjacent equal-format runs and drop empty ones, so two run lists
+ * describing the same content compare structurally equal.
+ *
+ * Necessary because Lexical's node boundaries are a rendering detail: `ab`+`c`
+ * and `abc` at the same format are the same document.
+ */
+export function normalizeRuns(runs) {
+    const out = [];
+    for (const run of runs) {
+        if (run.text === '')
+            continue;
+        const last = out[out.length - 1];
+        if (last !== undefined && last.format === run.format) {
+            out[out.length - 1] = { text: last.text + run.text, format: last.format };
+        }
+        else {
+            out.push({ text: run.text, format: run.format });
+        }
+    }
+    return out;
+}
+/** Project a `LoroText`'s delta into normalized Lexical-shaped runs. */
+export function runsFromDelta(delta) {
+    return normalizeRuns(delta.map((item) => ({
+        text: String(item.insert ?? ''),
+        format: bitmaskFromAttributes(item.attributes),
+    })));
+}
+/** Project a live `LoroText` into normalized Lexical-shaped runs. */
+export function runsFromText(text) {
+    return runsFromDelta(text.toDelta());
+}
+/**
+ * Expand runs into a per-character bitmask array.
+ *
+ * Per-character is what makes the run diff correct without special-casing:
+ * the two sides may be segmented completely differently (Lexical split a node
+ * where Loro did not), and comparing per character makes segmentation moot.
+ */
+function bitmaskPerCharacter(runs) {
+    const out = [];
+    for (const run of runs) {
+        for (let i = 0; i < run.text.length; i++)
+            out.push(run.format);
+    }
+    return out;
+}
+/**
+ * Diff two run lists into the minimal explicit `mark`/`unmark` ops that turn
+ * `current` into `target`.
+ *
+ * `current` is what Loro holds after the text edit landed (so `expand` has
+ * already had its say); `target` is the runs Lexical actually produced. Both
+ * MUST describe the same character count — call this only after the text
+ * content has been reconciled.
+ *
+ * Each format is diffed INDEPENDENTLY (that is the whole point of decomposing
+ * the bitmask) and differing characters are coalesced into maximal ranges, so a
+ * whole-paragraph bolding is one op, not one per character.
+ */
+export function diffRunFormats(current, target) {
+    const from = bitmaskPerCharacter(current);
+    const to = bitmaskPerCharacter(target);
+    if (from.length !== to.length) {
+        throw new Error(`lexical-loro: diffRunFormats requires equal-length runs — ` +
+            `current has ${from.length} chars, target has ${to.length}; ` +
+            'reconcile the text content before diffing formats');
+    }
+    const ops = [];
+    for (const format of LORO_TEXT_FORMATS) {
+        const bit = FORMAT_BITS[format];
+        let start = -1;
+        let openKind = 'mark';
+        // Iterate one PAST the end so a range still open at the last character is
+        // closed by the same branch as any other, with no duplicated tail logic.
+        for (let i = 0; i <= from.length; i++) {
+            let kind;
+            if (i < from.length) {
+                const wanted = (to[i] & bit) !== 0;
+                const has = (from[i] & bit) !== 0;
+                if (wanted !== has)
+                    kind = wanted ? 'mark' : 'unmark';
+            }
+            if (start !== -1 && kind !== openKind) {
+                ops.push({ kind: openKind, start, end: i, format });
+                start = -1;
+            }
+            if (kind !== undefined && start === -1) {
+                start = i;
+                openKind = kind;
+            }
+        }
+    }
+    return ops;
+}
+/**
+ * Apply {@link MarkOp}s to a `LoroText`. The caller owns the surrounding
+ * transaction (`doc.commit`), so a whole Lexical update lands as one Loro
+ * change and therefore as one remote event batch.
+ */
+export function applyMarkOps(text, ops) {
+    for (const op of ops) {
+        if (op.kind === 'mark')
+            text.mark({ start: op.start, end: op.end }, op.format, true);
+        else
+            text.unmark({ start: op.start, end: op.end }, op.format);
+    }
+}
+const HIGH_SURROGATE = /[\uD800-\uDBFF]/;
+const LOW_SURROGATE = /[\uDC00-\uDFFF]/;
+/**
+ * Diff `a` → `b`, biased to place the change at `cursor`.
+ *
+ * A plain "common prefix / common suffix" diff is ambiguous whenever the edit
+ * sits next to repeated characters: typing `o` in `foo` could be described as an
+ * insert at index 1, 2 or 3, and the plain diff always picks the leftmost. Every
+ * peer then sees the character inserted at the wrong place, which drags remote
+ * carets and (through Loro's `expand`) can even attach the wrong formatting.
+ *
+ * Biasing the prefix scan to stop AT the cursor resolves the ambiguity in favour
+ * of where the user actually typed. `@lexical/yjs` uses `simpleDiffWithCursor`
+ * for exactly this reason; this is that algorithm (lib0's
+ * `simpleDiffStringWithCursor`), including its surrogate-pair rollbacks, ported
+ * so the package carries no lib0 dependency.
+ *
+ * Surrogate handling: the scans never stop between the halves of a surrogate
+ * pair, so an astral character is always inserted or deleted whole.
+ *
+ * @param cursor UTF-16 offset of the caret in `b` (the new string).
+ */
+export function diffTextWithCursor(a, b, cursor) {
+    let left = 0;
+    let right = 0;
+    // Scan the common prefix, but stop at the cursor: the user's caret marks
+    // where the change really is.
+    while (left < a.length && left < b.length && a[left] === b[left] && left < cursor)
+        left++;
+    if (left > 0 && HIGH_SURROGATE.test(a[left - 1]))
+        left--;
+    // Scan the common suffix.
+    while (right + left < a.length &&
+        right + left < b.length &&
+        a[a.length - right - 1] === b[b.length - right - 1])
+        right++;
+    if (right > 0 && LOW_SURROGATE.test(a[a.length - right]))
+        right--;
+    // Resume the prefix scan past the cursor — anything still common there is not
+    // part of the edit, and leaving it in would make the diff larger than needed.
+    while (right + left < a.length && right + left < b.length && a[left] === b[left])
+        left++;
+    if (left > 0 && HIGH_SURROGATE.test(a[left - 1]))
+        left--;
+    return { index: left, remove: a.length - left - right, insert: b.slice(left, b.length - right) };
+}
+/**
+ * Cursor-free variant: the change is placed as far LEFT as possible.
+ *
+ * Equivalent to lib0's `simpleDiffString`. Use it only where no caret is known
+ * (a programmatic document change); prefer {@link diffTextWithCursor} on any
+ * user-typing path, where the leftmost placement is exactly the wrong guess.
+ */
+export function diffText(a, b) {
+    return diffTextWithCursor(a, b, 0);
+}
+/**
+ * Apply a {@link TextDiff} to a `LoroText`. A no-op diff writes nothing, so a
+ * Lexical update that changed only formatting produces no text ops (and so no
+ * spurious remote text event).
+ */
+export function applyTextDiff(text, diff) {
+    if (diff.remove > 0)
+        text.delete(diff.index, diff.remove);
+    if (diff.insert !== '')
+        text.insert(diff.index, diff.insert);
+}
+//# sourceMappingURL=text.js.map

package/dist/text.js.map

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

package/dist/to-lexical.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Inbound sync: the Loro mirror → a Lexical `EditorState`.
+ *
+ * ── The one thing this must not do ─────────────────────────────────────────
+ *
+ * loro-prosemirror's inbound path replaces the whole document on every remote
+ * event (`sync-plugin.ts`). ProseMirror tolerates that. LEXICAL CANNOT: its
+ * `NodeKey` is a bare counter (`LexicalUtils.ts`: `'' + keyCounter++`), so a
+ * rebuild mints a fresh key for every node, which tears down all DOM, destroys
+ * the selection and IME composition, and — decisively for this stack — destroys
+ * and remounts EVERY `LLuiDecoratorNode`, because `packages/lexical/decorator.ts`
+ * disposes the mounted LLui sub-app on the 'destroyed' mutation.
+ *
+ * So this module is a PERSISTENT MIRROR: it resolves each remote change to an
+ * existing `NodeKey` through the registry in `mapping.ts` and MUTATES THAT NODE
+ * IN PLACE. Nodes nothing touched are never written, so their keys — and
+ * therefore their DOM, their mounts, and any selection inside them — survive by
+ * construction. That is the model `@lexical/yjs`'s `SyncEditorStates.ts` uses,
+ * and it is the only one that works here.
+ *
+ * ── Why it reconciles from STATE, not from the deltas ──────────────────────
+ *
+ * The events say WHERE the document changed; this module then reconciles those
+ * containers against Loro's CURRENT state rather than replaying each delta. Four
+ * reasons, all learned from the event shapes loro-crdt actually emits:
+ *
+ *  1. A batch that creates a subtree emits the parent's list insert AND a
+ *     separate event for every descendant container. Replaying all of them
+ *     double-applies; reconciling from state is idempotent, so the duplicate
+ *     descriptions of one change collapse to one reconciliation.
+ *  2. A `LoroMovableList#move` arrives as an insert plus a delete carrying the
+ *     SAME `ContainerID`. Reconciling by identity recognises that as a move —
+ *     the whole point of the movable-list schema — where a delta replay would
+ *     see a delete and rebuild the subtree.
+ *  3. A map deletion is reported as an `undefined` value in `MapDiff.updated`,
+ *     which is indistinguishable from an absent key in most JS handling. Reading
+ *     the map is unambiguous.
+ *  4. It is the mirror image of `to-loro.ts`, so both directions share one
+ *     notion of "these two trees agree" (`text.ts`'s normalized runs) and cannot
+ *     drift apart in their idea of what a difference is.
+ *
+ * The events are therefore used as a DIRTY SET, exactly as `to-loro.ts` uses
+ * Lexical's `dirtyElements`/`dirtyLeaves`: every element on the path from the
+ * root to a changed container is marked, and the walk descends only into marked
+ * children. A remote keystroke costs O(tree depth), not O(document).
+ *
+ * ── Selection ──────────────────────────────────────────────────────────────
+ *
+ * Untouched nodes keep their keys, so a caret outside the changed run needs no
+ * help at all. Only the case where a remote change lands INSIDE the exact text
+ * run holding the caret needs work: there the caret's offset is transformed
+ * through the same single-region diff used to update the run (a caret at or
+ * before the edit point does not move; one after it shifts by
+ * `insert.length - remove`; one inside a deleted span clamps to the edit point).
+ * That is deliberately narrow — reaching for cursors more broadly would mean
+ * writing selection on every remote event, which is its own source of jitter.
+ */
+import { type LexicalEditor } from 'lexical';
+import { type LoroDoc, type LoroEventBatch } from 'loro-crdt';
+import { ContainerNodeMap } from './mapping.js';
+import { type ElementContainer } from './schema.js';
+/**
+ * Tags stamped on every inbound writeback.
+ *
+ * `COLLABORATION_TAG` is echo layer (b): `to-loro.ts` skips updates carrying it,
+ * so our own writeback cannot bounce back into the shared document.
+ * `SKIP_SCROLL_INTO_VIEW_TAG` stops a peer's edit from yanking the local
+ * viewport.
+ *
+ * `PROGRAMMATIC_TAG` is deliberately ABSENT and must stay that way — echo layer
+ * (c). `packages/lexical/src/foreign.ts` treats that tag as "the host pushed new
+ * content: cancel pending outbound work and rebase", so a remote writeback
+ * carrying it would silently cancel the local user's in-flight debounced
+ * `onChange` and the host's persistence would go dark whenever a peer types.
+ */
+export declare const INBOUND_TAGS: readonly string[];
+/** The Lexical side of the binding, plus the shared document it mirrors. */
+export interface InboundTarget {
+    readonly doc: LoroDoc;
+    /** The root element container, as returned by `initDoc`. */
+    readonly root: ElementContainer;
+    /** The ContainerID ↔ NodeKey registry, owned by the binding and mutated here. */
+    readonly mapping: ContainerNodeMap;
+    readonly editor: LexicalEditor;
+    /**
+     * Commit origins whose LOCAL batches must still be applied.
+     *
+     * Echo layer (a) drops `by: 'local'` batches — they are this peer's own
+     * outbound writes coming back round. But not every local batch is an echo:
+     *
+     *  - the CRDT-aware undo manager (`undo.ts`) produces LOCAL batches from
+     *    `undo()`/`redo()` (`UNDO_ORIGINS`), and
+     *  - the agent-write reconciler (`agent-write.ts`) writes the document directly
+     *    under {@link import('./agent-write.js').AGENT_WRITE_ORIGIN},
+     *
+     * neither of which came FROM the editor, so both MUST be applied to bounce into
+     * it (preserving `NodeKey`s and decorator mounts). `binding.ts` passes those
+     * origins here. A local batch whose origin is on this list is applied; every
+     * other local batch is still dropped as an echo.
+     */
+    readonly localOrigins?: readonly string[];
+}
+/**
+ * Apply one Loro event batch to the editor.
+ *
+ * @returns whether anything was applied. `false` means the batch was an echo of
+ * our own write, or described no change the editor could see.
+ */
+export declare function applyLoroToLexical(target: InboundTarget, batch: LoroEventBatch): boolean;
+/**
+ * Reconcile the ENTIRE shared document into the editor, with no dirty gate.
+ *
+ * Used at boot by a peer adopting a document it has no event history for (see
+ * `seed.ts`), and as the fallback whenever an event's container ancestry cannot
+ * be resolved. Full-fidelity and identity-preserving: adopting a document the
+ * editor already matches writes nothing and churns no NodeKeys.
+ */
+export declare function adoptLoroDocument(target: InboundTarget): boolean;
+//# sourceMappingURL=to-lexical.d.ts.map

package/dist/to-lexical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-lexical.d.ts","sourceRoot":"","sources":["../src/to-lexical.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH,OAAO,EAYL,KAAK,aAAa,EAMnB,MAAM,SAAS,CAAA;AAChB,OAAO,EAIL,KAAK,OAAO,EACZ,KAAK,cAAc,EACpB,MAAM,WAAW,CAAA;AAElB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EASL,KAAK,gBAAgB,EAEtB,MAAM,aAAa,CAAA;AAOpB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAAmD,CAAA;AAE7F,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAA;IAClC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;IAC9B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAaxF;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAEhE"}