edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/providers/room.js

@@ -41,10 +41,8 @@
  * - `handlers` — ws adds `messageAuth` (the auth reply exists only on a
  *   server socket — a BC room has no authority to deny).
  */
-import * as bc from 'lib0-v14/broadcastchannel';
 import * as encoding from 'lib0-v14/encoding';
 import * as decoding from 'lib0-v14/decoding';
-import * as env from 'lib0-v14/environment';
 import * as promise from 'lib0-v14/promise';
 import { applyAwarenessUpdate, encodeAwarenessUpdate } from '../protocols/awareness.js';
 import { BARE_REPLY_LENGTH, frame, GENERATION, writeProtocolVersion } from '../protocols/envelope.js';
@@ -171,6 +169,37 @@ export const createChunkReader = (maxBytes = Infinity, admit = () => true) => {
 };
 /** An awareness frame carrying `clients`' entries of `states` (default: their current ones). */
 const awarenessFrame = (awareness, clients, states) => frame(messageAwareness, (e) => encoding.writeVarUint8Array(e, encodeAwarenessUpdate(awareness, clients, states)));
+const channels = new Map();
+const channelNamed = (room) => {
+    let c = channels.get(room);
+    if (c === undefined) {
+        const subs = new Set();
+        const bc = new BroadcastChannel(room);
+        bc.onmessage = (e) => subs.forEach((sub) => sub(e.data, null));
+        channels.set(room, (c = { bc, subs }));
+    }
+    return c;
+};
+/**
+ * The tabs of one browser, by room name: one `BroadcastChannel` per room,
+ * shared by this tab's subscribers. A publish reaches the other tabs and,
+ * at once, this tab's other subscribers (with the publisher as origin).
+ */
+export const tabs = {
+    subscribe: (room, f) => void channelNamed(room).subs.add(f),
+    unsubscribe: (room, f) => {
+        const c = channels.get(room);
+        if (c?.subs.delete(f) && c.subs.size === 0) {
+            c.bc.close();
+            channels.delete(room);
+        }
+    },
+    publish: (room, data, origin = null) => {
+        const c = channelNamed(room);
+        c.bc.postMessage(data);
+        c.subs.forEach((sub) => sub(data, origin));
+    }
+};
 /** The outbound quarantine: a read-only document does not spread. */
 export const quarantined = (doc) => checkSchema(asEngineDoc(doc)) !== null;
 /**
@@ -201,7 +230,7 @@ export const initLifecycle = (host, destroy, depart = () => { }) => {
     }
     else {
         const leave = () => void destroy();
-        const proc = (env.isNode ? globalThis.process : undefined) ?? {};
+        const proc = globalThis.process ?? {};
         proc.on?.('exit', leave);
         host._leave = () => proc.off?.('exit', leave);
     }
@@ -344,21 +373,9 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
                 // valid envelope surfaces through 'message-error'.
                 // A pending forged stamp this update would release is discarded
                 // (`discarded`) and reported the same way.
-                // A SyncStep2 is v2 on the wire: converted, then the one inbound path.
-                const payload = decoding.readVarUint8Array(decoder);
+                const update = decoding.readVarUint8Array(decoder);
                 const origin = emitSynced ? provider : (behavior.tabOrigin?.(provider) ?? provider);
                 const onError = (error) => provider.emit?.('message-error', [error, provider]);
-                let update;
-                try {
-                    update =
-                        syncMessageType === syncProtocol.messageYjsSyncStep2
-                            ? syncProtocol.step2Update(payload)
-                            : payload;
-                }
-                catch (error) {
-                    onError(error);
-                    return;
-                }
                 const { applied, problem, discarded } = syncProtocol.applyRemote(provider.doc, update, origin, onError);
                 const refused = problem ?? discarded;
                 if (refused) {
@@ -426,7 +443,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
     const channelOf = (provider) => behavior.roomChannel(provider);
     /** The BC subscriber: replies go back on the room channel. */
     const bcSubscriber = (provider) => {
-        const send = (buf) => bc.publish(channelOf(provider), buf, provider);
+        const send = (buf) => tabs.publish(channelOf(provider), buf, provider);
         return (data, origin) => {
             if (origin === provider)
                 return;
@@ -434,7 +451,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
                 readMessage(provider, new Uint8Array(data), false, send);
             }
             catch (error) {
-                // lib0 delivers same-tab publishes synchronously — a malformed
+                // same-tab publishes are delivered synchronously — a malformed
                 // message must not propagate into the publisher's call stack.
                 provider.emit?.('message-error', [error, provider]);
             }
@@ -477,12 +494,12 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
     const connectBc = (provider) => {
         const channel = channelOf(provider);
         if (!provider.bcconnected) {
-            bc.subscribe(channel, provider._bcSubscriber);
+            tabs.subscribe(channel, provider._bcSubscriber);
             provider.bcconnected = true;
         }
         const [sv, presence] = hello(provider);
         for (const buf of [sv, frame(messageQueryAwareness, () => { }), presence]) {
-            bc.publish(channel, buf, provider);
+            tabs.publish(channel, buf, provider);
         }
     };
     /** The departure announcement — our presence, removed — on every transport the provider speaks. */
@@ -491,7 +508,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
     const disconnectBc = (provider) => {
         depart(provider);
         if (provider.bcconnected) {
-            bc.unsubscribe(channelOf(provider), provider._bcSubscriber);
+            tabs.unsubscribe(channelOf(provider), provider._bcSubscriber);
             provider.bcconnected = false;
         }
     };

package/dist/crdt/providers/websocket.d.ts

@@ -122,7 +122,7 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
             bcChannel: string;
             bcconnected: boolean;
             disableBc: boolean;
-            _bcSubscriber: (data: ArrayBuffer, origin: unknown) => void;
+            _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
             /** The transaction origin of updates heard from another tab. */
             _fromTab: {};
             wsUnsuccessfulReconnects: number;

package/dist/crdt/providers/websocket.js

@@ -31,7 +31,7 @@
  * via `'protocol-mismatch'`. A v13
  * y-websocket server in the room therefore cannot feed updates to this
  * provider (and vice versa) — see docs/crdt-v14-providers.md §server
- * classification: only an OPAQUE v1-update relay stays compatible; a server
+ * classification: only an OPAQUE relay stays compatible; a server
  * that participates in sync (like upstream `y-websocket-server`) must itself
  * run the vendored v14 engine + v14 protocol modules.
  *
@@ -46,7 +46,6 @@
  * re-sends a Step1 on the live socket for harnesses that drop frames
  * there (TCP never does).
  */
-import * as bc from 'lib0-v14/broadcastchannel';
 import * as decoding from 'lib0-v14/decoding';
 import * as time from 'lib0-v14/time';
 import * as math from 'lib0-v14/math';
@@ -57,7 +56,7 @@ import { messagePermissionDenied, messageReadOnly, READ_ONLY_DENIAL, readAuthMes
 import { bindSync } from '../protocols/sync.js';
 import { readCommentsMessage, writeCommentsSubscribe } from '../protocols/comments.js';
 import { frame } from '../protocols/envelope.js';
-import { assertRoomId, beginDestroy, bindRoomProtocol, chunkFrame, CLOSE, createChunkReader, emitFailed, initLifecycle, isRefusal, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
+import { assertRoomId, beginDestroy, bindRoomProtocol, tabs, chunkFrame, CLOSE, createChunkReader, emitFailed, initLifecycle, isRefusal, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
 import { asEngineDoc } from '../structs.js';
 import { ATTRIBUTION_ROOT } from '../schema.js';
 import { ATTRIBUTION_ORIGIN } from '../attribution/attribution.js';
@@ -95,7 +94,7 @@ export const bindWebsocketProvider = (Y) => {
     /** Traffic for the other tabs goes out on the channel. */
     const toTabs = (provider, buf) => {
         if (provider.bcconnected)
-            bc.publish(provider.bcChannel, buf, provider);
+            tabs.publish(provider.bcChannel, buf, provider);
     };
     /** Room traffic goes to the server and to the other tabs. */
     const broadcast = (provider, buf) => {

package/dist/crdt/purge.d.ts

@@ -13,8 +13,8 @@
  * held), a text delete mark record, a placement candidate.
  */
 import type { EngineApi, EngineDoc } from './engine-api.js';
-import type { PlacementModel } from './placement/model.js';
-import type { TextEngine } from './text/model.js';
+import { type PlacementModel } from './placement/model.js';
+import { type TextEngine } from './text/model.js';
 /** The horizon: the time and encoded state vector of the room's epoch (`room.purge.timing`). */
 export type Horizon = {
     at: number;

package/dist/crdt/purge.js

@@ -1,5 +1,8 @@
+import { view as modelView } from './placement/model.js';
+import { purgeStreams } from './text/model.js';
 import { AT, BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, isNodeLike, REC_PREFIX, REGISTRY_KEY, WITHDRAW_PREFIX } from './schema.js';
 import { bindDeletes } from './text/deletes.js';
+import { deleteIndex } from './text/delete-index.js';
 import { baseIdOf, isIncarnationId } from './incarnations.js';
 import { attrItems, firstItem } from './structs.js';
 const mapOf = (node) => attrItems(node);
@@ -12,14 +15,74 @@ export const readHorizon = (doc) => {
 };
 export const bindPurge = (Y) => {
     const D = bindDeletes(Y);
+    const { rootSpans, holders, dropMarks, recordsIn, copiesOf, liveRoots, forget, collect } = deleteIndex(Y);
+    /**
+     * Whether every live mark holding a character of `spans` was written
+     * where `old` says (a withdrawn block's content was deleted
+     * before the horizon). Characters no mark holds count as old.
+     */
+    const heldBefore = (doc, spans, old) => {
+        const s = D.state(doc);
+        return spans
+            .flatMap((sp) => rootSpans(s, sp))
+            .every((r) => holders(s, r).every((mark) => old(mark.client, mark.clock)));
+    };
+    /**
+     * The text's part (`room.purge.what`), inside the purge
+     * transaction: delete every text delete mark record `old` names, and
+     * every restoration record `old` names whose copies are all deleted
+     * and that no remaining mark holds; its copies are forgotten (the
+     * `gcFilter` no longer keeps them) and collected. Writes no mark.
+     */
+    const purgeText = (doc, old) => {
+        const s = D.state(doc);
+        const tr = s.doc._transaction;
+        if (tr === null)
+            throw new Error('purge: outside a transaction');
+        const spans = [];
+        const dropped = [];
+        for (let it = firstItem(s.marks); it; it = it.right)
+            if (!it.deleted)
+                for (let j = 0; j < it.length; j++) {
+                    const r = { client: it.id.client, clock: it.id.clock + j };
+                    if (!old(r.client, r.clock))
+                        continue;
+                    dropped.push(r);
+                    const last = spans[spans.length - 1];
+                    if (last !== undefined && last.c === r.client && last.k + last.n === r.clock)
+                        last.n++;
+                    else
+                        spans.push({ c: r.client, k: r.clock, n: 1 });
+                }
+        dropMarks(s, dropped);
+        const marks = dropped.length;
+        D.remove(tr, spans);
+        const doomed = [];
+        attrItems(s.restored).forEach((it, key) => {
+            if (it.deleted || !old(it.id.client, it.id.clock))
+                return;
+            const [record, bytes] = recordsIn(it, null)[0] ?? [];
+            if (bytes === undefined)
+                return;
+            const copies = copiesOf(record, bytes);
+            const dead = copies.every((e) => liveRoots(s, { c: e.c, k: e.k, n: e.n, rk: e.k }).length === 0 &&
+                holders(s, { c: e.rc, k: e.rk, n: e.n }).length === 0);
+            if (dead)
+                doomed.push({ key, copies });
+        });
+        for (const { key, copies } of doomed) {
+            s.restored.deleteAttr(key);
+            forget(s, copies);
+            collect(s, tr, copies);
+        }
+        return { marks, records: doomed.length };
+    };
     /**
      * Purge from `doc` (through `facade`, the facade over it) what was
      * deleted before `horizon`, and write the horizon record. Runs inside the
      * caller's transaction.
      */
     const purge = (doc, facade, horizon) => {
-        const M = facade.model;
-        const T = facade.text;
         const report = {
             removed: 0,
             emptied: 0,
@@ -32,7 +95,7 @@ export const bindPurge = (Y) => {
         const vector = Y.decodeStateVector(horizon.sv);
         const old = (client, clock) => clock < (vector.get(client) ?? 0);
         const oldItem = (item) => item !== undefined && !item.deleted && old(item.id.client, item.id.clock);
-        const view = M.view(doc);
+        const view = modelView(doc);
         const { blocks, own, placements } = view;
         const marks = (node, prefix) => [...node.attrKeys()]
             .filter((key) => key.startsWith(prefix))
@@ -93,7 +156,7 @@ export const bindPurge = (Y) => {
                 if (dead.has(id))
                     continue;
                 const s = own.streamOf(id);
-                if (s !== undefined && !D.heldBefore(doc, regionSpans(s), old))
+                if (s !== undefined && !heldBefore(doc, regionSpans(s), old))
                     continue;
                 const left = (children.get(id) ?? []).every((child) => {
                     const rec = blocks.get(child);
@@ -157,7 +220,7 @@ export const bindPurge = (Y) => {
         // A deleted block that stays: its stream's text (boundaries kept), its
         // data leaves and its claims.
         const emptied = [...dead].filter((id) => !removable.has(id));
-        T.purgeStreams(emptied.flatMap((id) => {
+        purgeStreams(emptied.flatMap((id) => {
             const s = own.streamOf(id);
             return s === undefined || s.end - s.start <= s.inert.length ? [] : [s];
         }));
@@ -250,7 +313,7 @@ export const bindPurge = (Y) => {
             report.candidates += rec.cands.length - 1;
         }
         // Text delete marks and restoration records past the horizon.
-        const text = D.purge(doc, old);
+        const text = purgeText(doc, old);
         report.marks = text.marks;
         report.records = text.records;
         // The horizon record, last.

package/dist/crdt/rangeDelete.d.ts

@@ -40,52 +40,14 @@
  *   (`table.range`);
  * - the plan's `at` is where the caret lands (`del.range.caret`).
  */
-import type { BlockId, Destination } from './placement/model.js';
-import type { Plan, PlanStep, Prepared } from './edytor-doc.js';
+import type { BlockId } from './placement/model.js';
+import type { Prepared } from './edytor-doc.js';
+import type { OpsContext } from './doc/steps.js';
 /** A position in one document version: a block and a display offset. */
 export type DocPosition = {
     block: BlockId;
     offset: number;
 };
-/** What range deletion reads from the document and the step writers it composes. */
-export type RangeDeleteContext = {
-    ref: (id: BlockId) => BlockId;
-    refused: Prepared;
-    plan: (ids: readonly BlockId[], writes: PlanStep[]) => Plan;
-    order: () => {
-        ids: readonly BlockId[];
-        at: ReadonlyMap<BlockId, number>;
-    };
-    positionOf: (id: BlockId) => Destination | null;
-    /** Display ancestors, nearest first (the root excluded). */
-    ancestorsOf: (id: BlockId) => BlockId[];
-    childrenIds: (parent: BlockId | null) => BlockId[];
-    displayLength: (id: BlockId) => number;
-    /** Live, with its own content node. */
-    contentTarget: (id: BlockId) => boolean;
-    rendersContent: (id: BlockId) => boolean;
-    canMerge: (from: BlockId, into: BlockId) => boolean;
-    isIsland: (id: BlockId) => boolean;
-    /** An island declared `lines` (a code block): it holds only lines. */
-    isLines: (id: BlockId) => boolean;
-    move: (ids: BlockId[], parent: BlockId | null, index: number) => PlanStep[];
-    /** A block that shows only its children: a list, a table row, a column. */
-    isContainer: (id: BlockId) => boolean;
-    /** A container that goes once it loses every child (it holds no text of its own). */
-    emptiable: (id: BlockId) => boolean;
-    /** The kind steps for `from`'s children `kids` landing under `parent` (island and container rules). */
-    settle: (from: BlockId | null, kids: readonly BlockId[], parent: BlockId | null) => PlanStep[];
-    remove: (id: BlockId, kept: readonly BlockId[]) => PlanStep;
-    /**
-     * The steps that dissolve each layout the plan leaves with one item or
-     * none (`layout.dissolving`): `gone` it removes, `leaving` it moves.
-     */
-    dissolving: (gone: readonly BlockId[], leaving: readonly BlockId[], writes: readonly PlanStep[]) => PlanStep[];
-    /** The table `id` is, or whose row or cell it is; `null` for any other block (`table.*`). */
-    tableOf: (id: BlockId) => BlockId | null;
-    /** `id` is a table's cell. */
-    isTableCell: (id: BlockId) => boolean;
-};
 /**
  * What the view knows of a range (view state the document does not hold):
  * whether it hides a block, and, given `removed`, whether the block stays
@@ -95,7 +57,7 @@ export type RangeView = {
     hidden?: (id: BlockId, removed?: ReadonlySet<BlockId>) => boolean;
 };
 /** `deleteRange` and `replaceRange` (the head kept), prepared. */
-export declare const rangeDeleteOps: (c: RangeDeleteContext) => {
+export declare const rangeDeleteOps: (c: OpsContext) => {
     deleteRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
     replaceRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
 };

package/dist/crdt/rangeDelete.js

@@ -1,3 +1,4 @@
+import { ref } from './doc/plan.js';
 /** `deleteRange` and `replaceRange` (the head kept), prepared. */
 export const rangeDeleteOps = (c) => {
     // `headSpent`: a whole-doc retry keeps the head, but what it hid goes as if it went.
@@ -5,14 +6,14 @@ export const rangeDeleteOps = (c) => {
         // A position names shown text: a live block that renders its own content.
         const holds = (id) => c.contentTarget(id) && c.rendersContent(id);
         const pos = (p) => {
-            const block = c.ref(p.block);
+            const block = ref(p.block);
             const len = holds(block) ? c.displayLength(block) : -1;
             return { block, offset: Math.max(0, Math.min(p.offset, len)) };
         };
         let [s, e] = [pos(from), pos(to)];
         if (!holds(s.block) || !holds(e.block))
-            return c.refused;
-        const { ids, at } = c.order();
+            return c.REFUSED;
+        const { ids, at } = c.view().order;
         if (at.get(s.block) > at.get(e.block) || (s.block === e.block && s.offset > e.offset))
             [s, e] = [e, s];
         const S = s.block;
@@ -104,7 +105,7 @@ export const rangeDeleteOps = (c) => {
             if (!doomed.has(parent(id)))
                 writes.push(c.remove(id, kept));
         // A layout the range leaves with one column dissolves (`layout.dissolving`).
-        writes.push(...c.dissolving([...doomed, ...(merges ? [E] : [])], rescued, writes));
+        writes.push(...c.dissolving(new Set([...doomed, ...(merges ? [E] : [])]), rescued, writes));
         const caret = (() => {
             if (!doomed.has(S))
                 return s;
@@ -135,7 +136,7 @@ export const rangeDeleteOps = (c) => {
      * come after the start in reading order); the caret lands at the start.
      */
     const inTables = (s, e, view) => {
-        const { ids, at } = c.order();
+        const { ids, at } = c.view().order;
         const [S, E] = [s.block, e.block];
         const kept = new Set(c.ancestorsOf(E));
         const between = ids.slice(at.get(S) + 1, at.get(E)).filter((id) => !view.hidden?.(id));
@@ -161,7 +162,7 @@ export const rangeDeleteOps = (c) => {
         const roots = [...doomed].filter((id) => !doomed.has(parentOf(id)));
         for (const id of roots)
             writes.push(c.remove(id, []));
-        writes.push(...c.dissolving(roots, [], writes));
+        writes.push(...c.dissolving(new Set(roots), [], writes));
         return { ...c.plan([S], writes), at: s };
     };
     return { deleteRange: prepare(false), replaceRange: prepare(true) };

package/dist/crdt/restore.d.ts

@@ -24,9 +24,29 @@
  * 6. the document's data, patched to the snapshot's.
  */
 import type { EngineDoc } from './engine-api.js';
-import type { BlockId, ContentItem, InlineSpec, PlacementModel } from './placement/model.js';
+import { type BlockId, type ContentItem, type InlineSpec, type PlacementModel } from './placement/model.js';
 import type { DataPatch } from './data.js';
 import type { JSONDoc } from '../utils/json.js';
+/** One display unit: a character (a code point) with its marks, or an inline atom, keyed for comparison. */
+export type Unit = {
+    key: string;
+    item: ContentItem;
+};
+/** `items` one unit each (a character with its marks, or an atom), keyed for comparison. */
+export declare const unitsOf: (items: readonly ContentItem[]) => Unit[];
+/** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
+export declare const hunk: (x: readonly Unit[], y: readonly Unit[]) => {
+    p: number;
+    e: number;
+    mid: Unit[];
+};
+/**
+ * Make block `id`'s content, `have` (its units now), read `want`: the one
+ * changed stretch between their common prefix and suffix is deleted and
+ * written again through the facade (an atom without an id gets a fresh
+ * one). Whether it wrote anything.
+ */
+export declare const rewriteContent: <Plan>(facade: Pick<RestoreFacade<Plan>, "apply" | "prepare">, id: BlockId, have: readonly Unit[], want: readonly Unit[]) => boolean;
 export type RestoreReport = {
     /** Blocks revived (their delete or withdraw marks removed). */
     revived: number;

package/dist/crdt/restore.js

@@ -1,10 +1,11 @@
+import { blockNodeOf, materializeSpec, ranksAt, view as modelView, writePlacement } from './placement/model.js';
 import { DEL_PREFIX, TYPE, WITHDRAW_PREFIX } from './schema.js';
-import { patchWrites, writeLeaves } from './data.js';
+import { common, patchWrites, writeLeaves } from './data.js';
 import { canonKey } from './text/model.js';
 import { randOf } from './rand.js';
 import { toBlockSpec } from '../utils/json.js';
 /** `items` one unit each (a character with its marks, or an atom), keyed for comparison. */
-const unitsOf = (items) => {
+export const unitsOf = (items) => {
     const out = [];
     for (const item of items) {
         if (item.kind === 'inline') {
@@ -42,6 +43,47 @@ const runsOf = (units) => {
     }
     return out;
 };
+/** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
+export const hunk = (x, y) => {
+    let p = 0;
+    while (p < x.length && p < y.length && x[p].key === y[p].key)
+        p++;
+    let q = 0;
+    while (q < x.length - p &&
+        q < y.length - p &&
+        x[x.length - 1 - q].key === y[y.length - 1 - q].key)
+        q++;
+    return { p, e: x.length - q, mid: y.slice(p, y.length - q) };
+};
+/** A unit's width in the block's offsets (a character's UTF-16 length; an atom counts 1). */
+const width = (u) => (u.item.kind === 'text' ? u.item.text.length : 1);
+/**
+ * Make block `id`'s content, `have` (its units now), read `want`: the one
+ * changed stretch between their common prefix and suffix is deleted and
+ * written again through the facade (an atom without an id gets a fresh
+ * one). Whether it wrote anything.
+ */
+export const rewriteContent = (facade, id, have, want) => {
+    const { p, e, mid } = hunk(have, want);
+    if (p === e && mid.length === 0)
+        return false;
+    let at = have.slice(0, p).reduce((n, u) => n + width(u), 0);
+    const gone = have.slice(p, e).reduce((n, u) => n + width(u), 0);
+    if (gone > 0)
+        facade.apply(facade.prepare.deleteText(id, at, gone));
+    for (const item of runsOf(mid)) {
+        if (item.kind === 'text') {
+            facade.apply(facade.prepare.insertText(id, at, item.text, item.marks ?? {}));
+            at += item.text.length;
+        }
+        else {
+            const atom = { id: item.id || crypto.randomUUID(), type: item.type, data: item.data };
+            facade.apply(facade.prepare.insertInline(id, at, atom));
+            at += 1;
+        }
+    }
+    return true;
+};
 /** Visible-tree order of `specs` with each block's snapshot parent. */
 const walk = (specs, parent, into) => {
     for (const spec of specs) {
@@ -50,43 +92,16 @@ const walk = (specs, parent, into) => {
     }
     return into;
 };
-/** The ids of `list` (positions in another order, `-1` absent) on its longest increasing run. */
-const longestRun = (positions) => {
-    const tails = [];
-    const tailAt = [];
-    const links = new Array(positions.length).fill(-1);
-    positions.forEach((position, i) => {
-        if (position < 0)
-            return;
-        let lo = 0;
-        let hi = tails.length;
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (tails[mid] < position)
-                lo = mid + 1;
-            else
-                hi = mid;
-        }
-        tails[lo] = position;
-        tailAt[lo] = i;
-        links[i] = lo > 0 ? tailAt[lo - 1] : -1;
-    });
-    const kept = new Set();
-    for (let i = tails.length ? tailAt[tails.length - 1] : -1; i !== -1; i = links[i])
-        kept.add(i);
-    return kept;
-};
 /**
  * Make the visible document `doc` (through `facade`, the facade over it)
  * equal `json`. Runs inside the caller's transaction; the writer is
  * `doc.clientID`. See the module comment for what it writes.
  */
 export const restoreDocument = (doc, facade, json) => {
-    const M = facade.model;
     const report = { revived: 0, moved: 0, rewritten: 0, created: 0, deleted: 0 };
     const specs = json.children.map((block) => toBlockSpec(block));
     const all = walk(specs, null, new Map());
-    const node = (id) => M.blockNodeOf(doc, id);
+    const node = (id) => blockNodeOf(doc, id);
     // 1 · Revive, and free every snapshot block from the claims on it.
     for (const id of all.keys()) {
         const n = node(id);
@@ -99,7 +114,7 @@ export const restoreDocument = (doc, facade, json) => {
             report.revived++;
     }
     {
-        const { blocks } = M.view(doc);
+        const { blocks } = modelView(doc);
         for (const rec of blocks.values()) {
             // A deleted holder's claims are void (and stay so): only the others.
             if (rec.deleted || rec.claimsNode === undefined)
@@ -131,7 +146,8 @@ export const restoreDocument = (doc, facade, json) => {
             continue;
         const slots = facade.childSlots(parent);
         const index = new Map(slots.map((slot, i) => [slot.id, i]));
-        const kept = longestRun(list.map((spec) => index.get(spec.id) ?? -1));
+        // What a longest common run of the two orders keeps stays where it is.
+        const kept = new Set(common(slots.map((slot) => slot.id), list.map((spec) => spec.id)).map(([, j]) => j));
         let prev;
         list.forEach((spec, i) => {
             if (kept.has(i)) {
@@ -148,14 +164,14 @@ export const restoreDocument = (doc, facade, json) => {
                 ...(prev === undefined ? [] : [{ rank: prev }]),
                 ...(next === undefined ? [] : [{ rank: next }])
             ];
-            const [rank] = M.ranksAt(bounds, prev === undefined ? 0 : 1, 1, doc.clientID, randOf(doc));
+            const [rank] = ranksAt(bounds, prev === undefined ? 0 : 1, 1, doc.clientID, randOf(doc));
             const n = node(spec.id);
             if (n === null) {
-                M.materializeSpec(doc, { ...spec, children: [] }, parent, rank);
+                materializeSpec(doc, { ...spec, children: [] }, parent, rank);
                 report.created++;
             }
             else {
-                M.writePlacement(doc, n, parent, rank);
+                writePlacement(doc, n, parent, rank);
                 report.moved++;
             }
             prev = rank;
@@ -167,39 +183,18 @@ export const restoreDocument = (doc, facade, json) => {
         let have = unitsOf(facade.contentItems(id));
         if (have.length === want.length && have.every((u, i) => u.key === want[i].key))
             continue;
-        const rec = M.view(doc).blocks.get(id);
+        const rec = modelView(doc).blocks.get(id);
         const claims = rec?.claimsNode;
         if (claims !== undefined && claims.length > 0) {
             claims.delete(0, claims.length);
             have = unitsOf(facade.contentItems(id));
         }
-        let head = 0;
-        while (head < have.length && head < want.length && have[head].key === want[head].key)
-            head++;
-        let tail = 0;
-        while (tail < have.length - head &&
-            tail < want.length - head &&
-            have[have.length - 1 - tail].key === want[want.length - 1 - tail].key)
-            tail++;
-        const removed = have.length - head - tail;
-        if (removed > 0)
-            facade.apply(facade.prepare.deleteText(id, head, removed));
-        let at = head;
-        for (const item of runsOf(want.slice(head, want.length - tail))) {
-            if (item.kind === 'text') {
-                facade.apply(facade.prepare.insertText(id, at, item.text, item.marks ?? {}));
-                at += item.text.length;
-            }
-            else {
-                facade.apply(facade.prepare.insertInline(id, at, { id: item.id, type: item.type, data: item.data }));
-                at += 1;
-            }
-        }
+        rewriteContent(facade, id, have, want);
         report.rewritten++;
     }
     // 5 · Every visible block outside the snapshot is deleted, with what it displays.
     for (let round = 0; round < 8; round++) {
-        const view = M.view(doc);
+        const view = modelView(doc);
         const extra = view.order.ids.filter((id) => !all.has(id));
         if (extra.length === 0)
             break;

package/dist/crdt/schema.d.ts

@@ -50,7 +50,7 @@ export declare const INLINE_NODE = "inline";
 /** Attr keys on a block node (`SCHEMA.blockAttrs`). */
 export declare const ID = "id";
 export declare const TYPE = "type";
-/** A block's or atom's whole data: the legacy layer, read under the leaves and exploded by the first patch. */
+/** A block's or atom's whole data, as documents before 0.1.0-next.6 stored it: no longer read; the room's purge deletes it. */
 export declare const DATA = "data";
 /** A data leaf: `d/` and its path, RFC 6901 escaped (`crdt/data.ts`). */
 export declare const DATA_LEAF_PREFIX = "d/";
@@ -91,7 +91,7 @@ export declare const AT = "at";
 export declare const REC_PREFIX = "b/";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
-    readonly version: 5;
+    readonly version: 6;
     readonly name: "edytor-doc";
     readonly roots: {
         readonly registry: "blocks";