@llui/lexical-loro 0.1.0

package/dist/binding.js

@@ -0,0 +1,114 @@
+/**
+ * `loroCollab(config)` — the binding that drives both directions.
+ *
+ * It composes `to-loro.ts` (Lexical → Loro), `to-lexical.ts` (Loro → Lexical)
+ * and `seed.ts` (boot) into one `register(editor)` step you hand to
+ * `lexicalForeign({ history: false, seedMode: 'deferred', register })`. The
+ * returned handle satisfies `@llui/markdown-editor`'s `CollabBinding`
+ * structurally, so that package needs no Loro dependency of its own.
+ *
+ * ── Transport ──────────────────────────────────────────────────────────────
+ *
+ * There is none, deliberately. `LoroDoc` already exposes the whole wire surface
+ * (`subscribeLocalUpdates` / `import` / `export`), so a transport is a dozen
+ * lines the consumer writes against their own websocket, WebRTC channel or
+ * `loro-websocket` provider — and baking one in would make this package own a
+ * connection lifecycle it has no way to test honestly. Pass the same `LoroDoc`
+ * to your provider and to `loroCollab`.
+ *
+ * ── The three echo layers, and where each one lives ────────────────────────
+ *
+ * All three are required; any one missing produces an infinite loop or, worse,
+ * a silent data-loss bug:
+ *
+ *  a. Loro → us. A LOCAL Loro batch is our own outbound write completing its
+ *     commit. `applyLoroToLexical` drops it (`to-lexical.ts`). Without this the
+ *     binding re-enters `editor.update` from inside a Lexical update listener.
+ *  b. us → Lexical → us. Our inbound writeback is tagged `COLLABORATION_TAG`,
+ *     which `syncLexicalToLoro` skips (`to-loro.ts`). Without this every remote
+ *     keystroke is echoed straight back to its sender.
+ *  c. THE SEAM. This binding NEVER emits `PROGRAMMATIC_TAG`.
+ *     `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 cancel the local user's in-flight debounced `onChange`
+ *     and the host's persistence would go dark whenever a peer types. There is
+ *     no code here to enforce this; there is simply no line that emits it, and
+ *     `test/to-lexical.test.ts` pins that.
+ *
+ * ── Undo ───────────────────────────────────────────────────────────────────
+ *
+ * This binding OWNS undo, via `externalUndo` (`undo.ts`, a Loro `UndoManager`
+ * scoped to this peer). Hosts must therefore turn their built-in
+ * `@lexical/history` stack off — `lexicalForeign` does that for you the moment
+ * `externalUndo` is present, so the two can never both be live.
+ *
+ * Loro's manager is operation-based and PeerID-scoped: undo reverts exactly the
+ * local user's own last change and never a peer's, which snapshot-based history
+ * cannot do at any tag setting. See `undo.ts` for why, and for the echo seam the
+ * undo batches travel through.
+ */
+import { LoroDoc } from 'loro-crdt';
+import { AGENT_WRITE_ORIGIN } from './agent-write.js';
+import { ContainerNodeMap } from './mapping.js';
+import { bootstrapDocument } from './seed.js';
+import { initDoc } from './schema.js';
+import { LORO_TEXT_FORMATS } from './text.js';
+import { applyLoroToLexical } from './to-lexical.js';
+import { OUTBOUND_ORIGIN, syncLexicalToLoro } from './to-loro.js';
+import { registerLoroUndo, UNDO_ORIGINS } from './undo.js';
+/**
+ * Build a collaborative-editing binding over a Loro document.
+ *
+ * The document is configured for this package's schema (`initDoc`) immediately,
+ * not at `register` time, so a transport may be attached to `collab.doc` before
+ * any editor exists.
+ */
+export function loroCollab(config = {}) {
+    const doc = config.doc ?? new LoroDoc();
+    // Must run on EVERY peer: `configTextStyle` is local configuration, not
+    // replicated state, and a peer that skips it resolves marks under different
+    // expand rules and diverges. Idempotent, so a shared doc may be passed to
+    // more than one binding.
+    const root = initDoc(doc, LORO_TEXT_FORMATS);
+    const mapping = new ContainerNodeMap();
+    const origin = config.origin ?? OUTBOUND_ORIGIN;
+    const bootstrap = (editor) => {
+        const outcome = bootstrapDocument({
+            doc,
+            root,
+            mapping,
+            editor,
+            seed: config.seed,
+            shouldBootstrap: config.shouldBootstrap,
+        });
+        config.onBootstrap?.(outcome);
+        return outcome;
+    };
+    const register = (editor) => {
+        const outboundTarget = { doc, root, mapping, origin };
+        // `localOrigins` are the local batches the inbound path must still APPLY
+        // rather than drop as an echo (see `to-lexical.ts`). Both are passed
+        // unconditionally: only a Loro `UndoManager` produces `UNDO_ORIGINS` and only
+        // `reconcileTargetIntoLoro` produces `AGENT_WRITE_ORIGIN`, so listing them is
+        // inert until one occurs — and the inbound path stays independent of whether
+        // `externalUndo` was registered or an agent write ever happens.
+        const localOrigins = [...UNDO_ORIGINS, AGENT_WRITE_ORIGIN];
+        const inboundTarget = { doc, root, mapping, editor, localOrigins };
+        // Inbound BEFORE outbound: the subscription must be live before the
+        // bootstrap writes anything, or a document arriving mid-boot is missed.
+        const unsubscribe = doc.subscribe((batch) => {
+            applyLoroToLexical(inboundTarget, batch);
+        });
+        const unregister = editor.registerUpdateListener((payload) => {
+            syncLexicalToLoro(outboundTarget, payload);
+        });
+        bootstrap(editor);
+        return () => {
+            unregister();
+            unsubscribe();
+        };
+    };
+    const externalUndo = (editor) => registerLoroUndo({ doc, ...config.undo }, editor);
+    return { register, doc, root, mapping, bootstrap, externalUndo };
+}
+//# sourceMappingURL=binding.js.map

package/dist/binding.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `@llui/lexical-loro` — Loro CRDT binding for the LLui ↔ Lexical editor.
+ *
+ * Start at {@link loroCollab}: it composes everything below into a
+ * `register(editor)` plus an `externalUndo(editor)` you hand to
+ * `lexicalForeign({ seedMode: 'deferred', register, externalUndo })`, and it
+ * satisfies `@llui/markdown-editor`'s `CollabBinding` structurally.
+ *
+ * - `schema.ts`     — the Loro container shape mirroring a Lexical EditorState
+ * - `order.ts`      — fractional indexing: sibling order as a sortable property
+ * - `mapping.ts`    — the ContainerID ↔ NodeKey registry (the core invariant)
+ * - `text.ts`       — format-bitmask ↔ named-mark conversion, the run diff, and
+ *                     the cursor-biased text diff
+ * - `to-loro.ts`    — Lexical → Loro: the update-listener-driven mirror
+ * - `to-lexical.ts` — Loro → Lexical: the persistent, in-place mirror
+ * - `seed.ts`       — boot: seed an empty shared document, or adopt a populated one
+ * - `undo.ts`       — peer-scoped, CRDT-aware undo/redo over Loro's `UndoManager`
+ * - `binding.ts`    — `loroCollab`: both directions plus the echo guards
+ *
+ * ── Scope ──────────────────────────────────────────────────────────────────
+ *
+ * DOCUMENT SYNC plus LOCAL-ONLY UNDO. Undo is owned by this binding
+ * (`LoroCollab.externalUndo`), so a host MUST disable `@lexical/history` —
+ * `lexicalForeign` does that automatically once `externalUndo` is passed. Still
+ * out of scope: presence and remote cursors (additive, over Loro's
+ * `EphemeralStore`), and text-node `style` / `mode` / `detail` — the run model
+ * is `{text, format}`.
+ *
+ * ── Echo suppression ───────────────────────────────────────────────────────
+ *
+ * Three independent layers are ALL required; see `binding.ts` for where each
+ * one lives and what breaks without it. The one with no code to enforce it:
+ * this binding NEVER emits `PROGRAMMATIC_TAG`, because
+ * `packages/lexical/src/foreign.ts` reads that tag as "the host pushed content —
+ * cancel pending outbound work", which would make the host's persistence go dark
+ * whenever a peer types.
+ *
+ * `test/expand-semantics.test.ts` (51 tests) is the specification for the
+ * text-format half; read it before touching `text.ts`. `test/network.ts` is the
+ * multi-peer convergence harness, driven by `test/convergence.test.ts`.
+ */
+export { ROOT_CONTAINER, KEY_TYPE, KEY_PROPS, KEY_CHILDREN, KEY_UUID, KEY_POS, KEY_KIND, KEY_TEXT, DECORATOR_TYPE, KEY_BRIDGE_TYPE, KEY_DATA, ROOT_TYPE, TEXT_MARK_EXPAND, initDoc, newUuid, createElementChild, createTextChild, setChildPosition, deleteChild, orderedChildren, childCount, elementType, elementProps, elementChildren, isElementContainer, isTextContainer, isDecoratorElement, containerId, containerIsLive, type PropValue, type PropsContainer, type ElementContainer, type ElementShape, type ChildrenContainer, type ChildContainer, type ChildCarrier, type CarrierShape, type TextCarrier, type TextCarrierShape, type ChildEntry, type ChildKind, type ExpandType, } from './schema.js';
+export { DIGITS, between, allocate, allocateAt, jitterFor, comparePositions } from './order.js';
+export { ContainerNodeMap, type MappingEntry, type LivenessProbe } from './mapping.js';
+export { LORO_TEXT_FORMATS, FORMAT_BITS, KNOWN_FORMAT_MASK, formatBit, formatsFromBitmask, bitmaskFromFormats, bitmaskFromAttributes, runsText, normalizeRuns, runsFromDelta, runsFromText, diffRunFormats, applyMarkOps, diffTextWithCursor, diffText, applyTextDiff, type LoroTextFormat, type TextRun, type TextDeltaItem, type MarkOp, type TextDiff, } from './text.js';
+export { OUTBOUND_ORIGIN, OUTBOUND_SKIP_TAGS, syncLexicalToLoro, seedLoroFromLexical, longestIncreasingSubsequence, type OutboundTarget, type OutboundUpdate, } from './to-loro.js';
+export { INBOUND_TAGS, applyLoroToLexical, adoptLoroDocument, type InboundTarget, } from './to-lexical.js';
+export { bootstrapDocument, isSharedDocumentEmpty, type BootstrapOutcome, type BootstrapTarget, } from './seed.js';
+export { LORO_UNDO_ORIGIN, UNDO_ORIGINS, DEFAULT_MERGE_INTERVAL, DEFAULT_MAX_UNDO_STEPS, registerLoroUndo, type LoroUndoOptions, } from './undo.js';
+export { loroCollab, type LoroCollab, type LoroCollabConfig } from './binding.js';
+/**
+ * Agent-write: apply an LLM's full-document markdown REWRITE to the shared
+ * document by CONTENT, so unchanged blocks keep their `ContainerID`s (hence their
+ * `NodeKey`s and mounted decorator sub-apps, and any concurrent peer edit into
+ * them) instead of being recreated wholesale.
+ *
+ * `reconcileTargetIntoLoro` is a SIBLING to `syncLexicalToLoro`: it writes Loro
+ * directly under {@link AGENT_WRITE_ORIGIN} and does NOT consult the
+ * `ContainerNodeMap` (content matching is the point; the mapping self-heals on
+ * the inbound bounce into any live editor). The caller owns the markdown → target
+ * parse with its own `@lexical/markdown` transformer set — this package never
+ * depends on `@lexical/markdown` — and projects the parsed editor state with
+ * {@link targetFromEditorState} / {@link projectTarget}.
+ *
+ * Guarantees and the documented DUPLICATE-BLOCK caveat live on the functions and
+ * in the README.
+ */
+export { AGENT_WRITE_ORIGIN, reconcileTargetIntoLoro, projectTarget, targetFromEditorState, type TargetElement, type TargetText, type TargetChild, } from './agent-write.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EACL,cAAc,EACd,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,cAAc,EACd,eAAe,EACf,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,OAAO,EACP,OAAO,EACP,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACV,WAAW,EACX,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAE/F,OAAO,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAEtF,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,SAAS,EACT,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,EACR,aAAa,EACb,aAAa,EACb,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,QAAQ,GACd,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,4BAA4B,EAC5B,KAAK,cAAc,EACnB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAA;AAErB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,KAAK,aAAa,GACnB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,eAAe,GACrB,MAAM,WAAW,CAAA;AAElB,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEjF;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EACrB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,WAAW,GACjB,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1,69 @@
+/**
+ * `@llui/lexical-loro` — Loro CRDT binding for the LLui ↔ Lexical editor.
+ *
+ * Start at {@link loroCollab}: it composes everything below into a
+ * `register(editor)` plus an `externalUndo(editor)` you hand to
+ * `lexicalForeign({ seedMode: 'deferred', register, externalUndo })`, and it
+ * satisfies `@llui/markdown-editor`'s `CollabBinding` structurally.
+ *
+ * - `schema.ts`     — the Loro container shape mirroring a Lexical EditorState
+ * - `order.ts`      — fractional indexing: sibling order as a sortable property
+ * - `mapping.ts`    — the ContainerID ↔ NodeKey registry (the core invariant)
+ * - `text.ts`       — format-bitmask ↔ named-mark conversion, the run diff, and
+ *                     the cursor-biased text diff
+ * - `to-loro.ts`    — Lexical → Loro: the update-listener-driven mirror
+ * - `to-lexical.ts` — Loro → Lexical: the persistent, in-place mirror
+ * - `seed.ts`       — boot: seed an empty shared document, or adopt a populated one
+ * - `undo.ts`       — peer-scoped, CRDT-aware undo/redo over Loro's `UndoManager`
+ * - `binding.ts`    — `loroCollab`: both directions plus the echo guards
+ *
+ * ── Scope ──────────────────────────────────────────────────────────────────
+ *
+ * DOCUMENT SYNC plus LOCAL-ONLY UNDO. Undo is owned by this binding
+ * (`LoroCollab.externalUndo`), so a host MUST disable `@lexical/history` —
+ * `lexicalForeign` does that automatically once `externalUndo` is passed. Still
+ * out of scope: presence and remote cursors (additive, over Loro's
+ * `EphemeralStore`), and text-node `style` / `mode` / `detail` — the run model
+ * is `{text, format}`.
+ *
+ * ── Echo suppression ───────────────────────────────────────────────────────
+ *
+ * Three independent layers are ALL required; see `binding.ts` for where each
+ * one lives and what breaks without it. The one with no code to enforce it:
+ * this binding NEVER emits `PROGRAMMATIC_TAG`, because
+ * `packages/lexical/src/foreign.ts` reads that tag as "the host pushed content —
+ * cancel pending outbound work", which would make the host's persistence go dark
+ * whenever a peer types.
+ *
+ * `test/expand-semantics.test.ts` (51 tests) is the specification for the
+ * text-format half; read it before touching `text.ts`. `test/network.ts` is the
+ * multi-peer convergence harness, driven by `test/convergence.test.ts`.
+ */
+export { ROOT_CONTAINER, KEY_TYPE, KEY_PROPS, KEY_CHILDREN, KEY_UUID, KEY_POS, KEY_KIND, KEY_TEXT, DECORATOR_TYPE, KEY_BRIDGE_TYPE, KEY_DATA, ROOT_TYPE, TEXT_MARK_EXPAND, initDoc, newUuid, createElementChild, createTextChild, setChildPosition, deleteChild, orderedChildren, childCount, elementType, elementProps, elementChildren, isElementContainer, isTextContainer, isDecoratorElement, containerId, containerIsLive, } from './schema.js';
+export { DIGITS, between, allocate, allocateAt, jitterFor, comparePositions } from './order.js';
+export { ContainerNodeMap } from './mapping.js';
+export { LORO_TEXT_FORMATS, FORMAT_BITS, KNOWN_FORMAT_MASK, formatBit, formatsFromBitmask, bitmaskFromFormats, bitmaskFromAttributes, runsText, normalizeRuns, runsFromDelta, runsFromText, diffRunFormats, applyMarkOps, diffTextWithCursor, diffText, applyTextDiff, } from './text.js';
+export { OUTBOUND_ORIGIN, OUTBOUND_SKIP_TAGS, syncLexicalToLoro, seedLoroFromLexical, longestIncreasingSubsequence, } from './to-loro.js';
+export { INBOUND_TAGS, applyLoroToLexical, adoptLoroDocument, } from './to-lexical.js';
+export { bootstrapDocument, isSharedDocumentEmpty, } from './seed.js';
+export { LORO_UNDO_ORIGIN, UNDO_ORIGINS, DEFAULT_MERGE_INTERVAL, DEFAULT_MAX_UNDO_STEPS, registerLoroUndo, } from './undo.js';
+export { loroCollab } from './binding.js';
+/**
+ * Agent-write: apply an LLM's full-document markdown REWRITE to the shared
+ * document by CONTENT, so unchanged blocks keep their `ContainerID`s (hence their
+ * `NodeKey`s and mounted decorator sub-apps, and any concurrent peer edit into
+ * them) instead of being recreated wholesale.
+ *
+ * `reconcileTargetIntoLoro` is a SIBLING to `syncLexicalToLoro`: it writes Loro
+ * directly under {@link AGENT_WRITE_ORIGIN} and does NOT consult the
+ * `ContainerNodeMap` (content matching is the point; the mapping self-heals on
+ * the inbound bounce into any live editor). The caller owns the markdown → target
+ * parse with its own `@lexical/markdown` transformer set — this package never
+ * depends on `@lexical/markdown` — and projects the parsed editor state with
+ * {@link targetFromEditorState} / {@link projectTarget}.
+ *
+ * Guarantees and the documented DUPLICATE-BLOCK caveat live on the functions and
+ * in the README.
+ */
+export { AGENT_WRITE_ORIGIN, reconcileTargetIntoLoro, projectTarget, targetFromEditorState, } from './agent-write.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EACL,cAAc,EACd,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,cAAc,EACd,eAAe,EACf,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,OAAO,EACP,OAAO,EACP,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACV,WAAW,EACX,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,eAAe,GAchB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAE/F,OAAO,EAAE,gBAAgB,EAAyC,MAAM,cAAc,CAAA;AAEtF,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,SAAS,EACT,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,EACR,aAAa,EACb,aAAa,EACb,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,aAAa,GAMd,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,4BAA4B,GAG7B,MAAM,cAAc,CAAA;AAErB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,GAElB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,GAGtB,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,EACtB,gBAAgB,GAEjB,MAAM,WAAW,CAAA;AAElB,OAAO,EAAE,UAAU,EAA0C,MAAM,cAAc,CAAA;AAEjF;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,aAAa,EACb,qBAAqB,GAItB,MAAM,kBAAkB,CAAA"}

package/dist/mapping.d.ts

@@ -0,0 +1,115 @@
+/**
+ * The ContainerID ↔ NodeKey registry — the core invariant of this package.
+ *
+ * ── Why it exists ──────────────────────────────────────────────────────────
+ *
+ * Lexical's `NodeKey` is a bare per-session counter
+ * (`LexicalUtils.ts`: `return '' + keyCounter++`). It is meaningless to a peer
+ * and unstable across reloads. Loro's `ContainerID` is the stable, replicated
+ * address. Every sync operation is therefore a translation between the two, and
+ * this registry is the only place that translation is allowed to happen.
+ *
+ * There is also NO stable node-object identity to key off: Lexical CLONES a node
+ * on every write, so `node === node` fails across an update. The NodeKey string
+ * survives cloning; the object does not. Hence a key↔id map, never a WeakMap.
+ *
+ * ── THE INVARIANT ──────────────────────────────────────────────────────────
+ *
+ * The two internal maps are always exact inverses of each other: a BIJECTION.
+ *
+ *     byContainer.get(id) === key   ⟺   byNode.get(key) === id
+ *
+ * No ContainerID ever addresses two NodeKeys, and no NodeKey ever addresses two
+ * ContainerIDs. `link()` enforces this by evicting BOTH stale directions before
+ * writing, so a re-link can never leave a half-entry behind. A violated
+ * bijection is the failure mode that silently corrupts a document: a stale
+ * reverse entry makes an inbound remote edit land on the wrong Lexical node.
+ *
+ * ── When it must be updated ────────────────────────────────────────────────
+ *
+ * - local create/delete   — the user edited; mirror the change outbound
+ * - remote create/delete  — an inbound event created/removed a container
+ * - TEXT NORMALIZATION    — Lexical silently merges/splits adjacent TextNodes
+ *   and reports it via `normalizedNodes`. This is the easiest one to forget and
+ *   the one that corrupts the document: the surviving node keeps ONE key and the
+ *   others are discarded, so their entries must be re-linked or dropped. This is
+ *   also why inbound application runs `discrete: true` — without a synchronous
+ *   flush the normalization happens after we have already read back keys, and
+ *   the mapping drifts.
+ *
+ * Entries are never implicitly expired. Use `sweep()` after a structural change
+ * to drop entries whose container or node no longer exists.
+ */
+import type { ContainerID } from 'loro-crdt';
+import type { NodeKey } from 'lexical';
+/** One direction of a mapping entry, as reported by iteration and sweeps. */
+export interface MappingEntry {
+    readonly id: ContainerID;
+    readonly key: NodeKey;
+}
+/** Liveness probes used by {@link ContainerNodeMap.sweep}. */
+export interface LivenessProbe {
+    /** True when the container still exists in the Loro document. */
+    readonly hasContainer: (id: ContainerID) => boolean;
+    /** True when the node still exists in the Lexical editor state. */
+    readonly hasNode: (key: NodeKey) => boolean;
+}
+/**
+ * A bijective, explicitly-invalidated registry mapping Loro `ContainerID`s to
+ * Lexical `NodeKey`s. See the file header for the invariant it maintains.
+ */
+export declare class ContainerNodeMap {
+    #private;
+    /** Number of live entries. Both directions always agree on this. */
+    get size(): number;
+    /**
+     * Link a container to a node, replacing any previous link on EITHER side.
+     *
+     * Evicting both directions first is what preserves the bijection: linking
+     * `id → k2` when `id → k1` existed must also drop `k1 → id`, or `k1` keeps
+     * resolving to a container it no longer owns.
+     */
+    link(id: ContainerID, key: NodeKey): void;
+    /** The NodeKey addressed by a container, or `undefined` if unmapped. */
+    nodeKey(id: ContainerID): NodeKey | undefined;
+    /** The ContainerID addressing a node, or `undefined` if unmapped. */
+    containerId(key: NodeKey): ContainerID | undefined;
+    /**
+     * The NodeKey addressed by a container. Throws when unmapped.
+     *
+     * Prefer this on paths where a missing entry means the registry is already
+     * corrupt — failing loudly beats writing to the wrong node.
+     */
+    expectNodeKey(id: ContainerID): NodeKey;
+    /** The ContainerID addressing a node. Throws when unmapped. */
+    expectContainerId(key: NodeKey): ContainerID;
+    hasContainer(id: ContainerID): boolean;
+    hasNode(key: NodeKey): boolean;
+    /**
+     * Move a container's link to a different NodeKey, keeping the bijection.
+     *
+     * This is the TEXT-NORMALIZATION path: Lexical merged our run's node into a
+     * sibling, so the container must now address the survivor. Returns false when
+     * the container was not mapped (nothing to move).
+     */
+    rekey(id: ContainerID, key: NodeKey): boolean;
+    /** Drop the entry for a container. Returns whether one existed. */
+    unlinkContainer(id: ContainerID): boolean;
+    /** Drop the entry for a node. Returns whether one existed. */
+    unlinkNode(key: NodeKey): boolean;
+    /** Every live entry, in insertion order. */
+    entries(): MappingEntry[];
+    /**
+     * Drop every entry whose container or node no longer exists, and return the
+     * entries removed.
+     *
+     * Deleting a subtree removes many containers at once; rather than making every
+     * caller walk the removed subtree, sweep after the structural change. An entry
+     * is stale if EITHER side is gone — a half-live entry is exactly the corrupt
+     * state the invariant forbids.
+     */
+    sweep(probe: LivenessProbe): MappingEntry[];
+    /** Drop every entry. Used when the document is re-seeded from scratch. */
+    clear(): void;
+}
+//# sourceMappingURL=mapping.d.ts.map

package/dist/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../src/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CACtB;AAED,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAA;IACnD,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;CAC5C;AAED;;;GAGG;AACH,qBAAa,gBAAgB;;IAI3B,oEAAoE;IACpE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI;IASzC,wEAAwE;IACxE,OAAO,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,GAAG,SAAS;IAI7C,qEAAqE;IACrE,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS;IAIlD;;;;;OAKG;IACH,aAAa,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO;IAMvC,+DAA+D;IAC/D,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW;IAM5C,YAAY,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO;IAItC,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAI9B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO;IAM7C,mEAAmE;IACnE,eAAe,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO;IAQzC,8DAA8D;IAC9D,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAQjC,4CAA4C;IAC5C,OAAO,IAAI,YAAY,EAAE;IAIzB;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,EAAE;IAU3C,0EAA0E;IAC1E,KAAK,IAAI,IAAI;CAuBd"}

package/dist/mapping.js

@@ -0,0 +1,181 @@
+/**
+ * The ContainerID ↔ NodeKey registry — the core invariant of this package.
+ *
+ * ── Why it exists ──────────────────────────────────────────────────────────
+ *
+ * Lexical's `NodeKey` is a bare per-session counter
+ * (`LexicalUtils.ts`: `return '' + keyCounter++`). It is meaningless to a peer
+ * and unstable across reloads. Loro's `ContainerID` is the stable, replicated
+ * address. Every sync operation is therefore a translation between the two, and
+ * this registry is the only place that translation is allowed to happen.
+ *
+ * There is also NO stable node-object identity to key off: Lexical CLONES a node
+ * on every write, so `node === node` fails across an update. The NodeKey string
+ * survives cloning; the object does not. Hence a key↔id map, never a WeakMap.
+ *
+ * ── THE INVARIANT ──────────────────────────────────────────────────────────
+ *
+ * The two internal maps are always exact inverses of each other: a BIJECTION.
+ *
+ *     byContainer.get(id) === key   ⟺   byNode.get(key) === id
+ *
+ * No ContainerID ever addresses two NodeKeys, and no NodeKey ever addresses two
+ * ContainerIDs. `link()` enforces this by evicting BOTH stale directions before
+ * writing, so a re-link can never leave a half-entry behind. A violated
+ * bijection is the failure mode that silently corrupts a document: a stale
+ * reverse entry makes an inbound remote edit land on the wrong Lexical node.
+ *
+ * ── When it must be updated ────────────────────────────────────────────────
+ *
+ * - local create/delete   — the user edited; mirror the change outbound
+ * - remote create/delete  — an inbound event created/removed a container
+ * - TEXT NORMALIZATION    — Lexical silently merges/splits adjacent TextNodes
+ *   and reports it via `normalizedNodes`. This is the easiest one to forget and
+ *   the one that corrupts the document: the surviving node keeps ONE key and the
+ *   others are discarded, so their entries must be re-linked or dropped. This is
+ *   also why inbound application runs `discrete: true` — without a synchronous
+ *   flush the normalization happens after we have already read back keys, and
+ *   the mapping drifts.
+ *
+ * Entries are never implicitly expired. Use `sweep()` after a structural change
+ * to drop entries whose container or node no longer exists.
+ */
+/**
+ * A bijective, explicitly-invalidated registry mapping Loro `ContainerID`s to
+ * Lexical `NodeKey`s. See the file header for the invariant it maintains.
+ */
+export class ContainerNodeMap {
+    #byContainer = new Map();
+    #byNode = new Map();
+    /** Number of live entries. Both directions always agree on this. */
+    get size() {
+        return this.#byContainer.size;
+    }
+    /**
+     * Link a container to a node, replacing any previous link on EITHER side.
+     *
+     * Evicting both directions first is what preserves the bijection: linking
+     * `id → k2` when `id → k1` existed must also drop `k1 → id`, or `k1` keeps
+     * resolving to a container it no longer owns.
+     */
+    link(id, key) {
+        const previousKey = this.#byContainer.get(id);
+        if (previousKey !== undefined && previousKey !== key)
+            this.#byNode.delete(previousKey);
+        const previousId = this.#byNode.get(key);
+        if (previousId !== undefined && previousId !== id)
+            this.#byContainer.delete(previousId);
+        this.#byContainer.set(id, key);
+        this.#byNode.set(key, id);
+    }
+    /** The NodeKey addressed by a container, or `undefined` if unmapped. */
+    nodeKey(id) {
+        return this.#byContainer.get(id);
+    }
+    /** The ContainerID addressing a node, or `undefined` if unmapped. */
+    containerId(key) {
+        return this.#byNode.get(key);
+    }
+    /**
+     * The NodeKey addressed by a container. Throws when unmapped.
+     *
+     * Prefer this on paths where a missing entry means the registry is already
+     * corrupt — failing loudly beats writing to the wrong node.
+     */
+    expectNodeKey(id) {
+        const key = this.#byContainer.get(id);
+        if (key === undefined)
+            throw new Error(`lexical-loro: no NodeKey mapped for container ${id}`);
+        return key;
+    }
+    /** The ContainerID addressing a node. Throws when unmapped. */
+    expectContainerId(key) {
+        const id = this.#byNode.get(key);
+        if (id === undefined)
+            throw new Error(`lexical-loro: no ContainerID mapped for node ${key}`);
+        return id;
+    }
+    hasContainer(id) {
+        return this.#byContainer.has(id);
+    }
+    hasNode(key) {
+        return this.#byNode.has(key);
+    }
+    /**
+     * Move a container's link to a different NodeKey, keeping the bijection.
+     *
+     * This is the TEXT-NORMALIZATION path: Lexical merged our run's node into a
+     * sibling, so the container must now address the survivor. Returns false when
+     * the container was not mapped (nothing to move).
+     */
+    rekey(id, key) {
+        if (!this.#byContainer.has(id))
+            return false;
+        this.link(id, key);
+        return true;
+    }
+    /** Drop the entry for a container. Returns whether one existed. */
+    unlinkContainer(id) {
+        const key = this.#byContainer.get(id);
+        if (key === undefined)
+            return false;
+        this.#byContainer.delete(id);
+        this.#byNode.delete(key);
+        return true;
+    }
+    /** Drop the entry for a node. Returns whether one existed. */
+    unlinkNode(key) {
+        const id = this.#byNode.get(key);
+        if (id === undefined)
+            return false;
+        this.#byNode.delete(key);
+        this.#byContainer.delete(id);
+        return true;
+    }
+    /** Every live entry, in insertion order. */
+    entries() {
+        return [...this.#byContainer].map(([id, key]) => ({ id, key }));
+    }
+    /**
+     * Drop every entry whose container or node no longer exists, and return the
+     * entries removed.
+     *
+     * Deleting a subtree removes many containers at once; rather than making every
+     * caller walk the removed subtree, sweep after the structural change. An entry
+     * is stale if EITHER side is gone — a half-live entry is exactly the corrupt
+     * state the invariant forbids.
+     */
+    sweep(probe) {
+        const removed = [];
+        for (const [id, key] of this.#byContainer) {
+            if (probe.hasContainer(id) && probe.hasNode(key))
+                continue;
+            removed.push({ id, key });
+        }
+        for (const { id } of removed)
+            this.unlinkContainer(id);
+        return removed;
+    }
+    /** Drop every entry. Used when the document is re-seeded from scratch. */
+    clear() {
+        this.#byContainer.clear();
+        this.#byNode.clear();
+    }
+    /**
+     * Assert the bijection holds. A debugging/test aid: production paths maintain
+     * it structurally, so a failure here means a bug in this class, not a caller.
+     *
+     * @internal
+     */
+    assertBijective() {
+        if (this.#byContainer.size !== this.#byNode.size) {
+            throw new Error(`lexical-loro: mapping is not bijective — ${this.#byContainer.size} containers vs ${this.#byNode.size} nodes`);
+        }
+        for (const [id, key] of this.#byContainer) {
+            if (this.#byNode.get(key) !== id) {
+                throw new Error(`lexical-loro: mapping is not bijective at ${id} ↔ ${key}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=mapping.js.map

package/dist/mapping.js.map

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