edytor 5.0.0 → 7.0.0

package/dist/crdt/providers/room.js

@@ -63,6 +63,12 @@ export const messageChunk = 5;
  * room sends it only to a socket that subscribed.
  */
 export const messageComments = 6;
+/**
+ * Client → server, after a re-seed (`room.reseed.protocol`): the client's
+ * whole old document, its unsaved edits in it, for the room to rebase onto
+ * the current epoch. Sent only when the room asks (its epoch notice).
+ */
+export const messageRebase = 7;
 /** A WebSocket message limit on Cloudflare (32 MiB): a larger frame is sent as chunks. */
 export const MAX_FRAME_BYTES = 32 * 1024 * 1024;
 const chunkStart = 0;
@@ -293,6 +299,10 @@ export const markSynced = (host) => {
     host._settleSynced[0](host);
     return true;
 };
+/** Report `error` on `provider`'s error channel (`'message-error'`): a frame, a payload or a storage failure. */
+export const fault = (provider, error) => provider.emit?.('message-error', [error, provider]);
+/** A message type no handler claims inside a valid envelope: protocol skew, reported, never dropped silently. */
+export const unknownType = (provider, what, type) => fault(provider, new Error(`Unknown ${what} message type ${type}`));
 /**
  * Terminal `'failed'` emission (the sync-failure contract): fires at
  * most once per provider, only while it has never synced — destroy before
@@ -330,6 +340,15 @@ export const CLOSE = {
     denied: 4403,
     /** The dialed replica is bound to another user. */
     replicaTaken: 4409,
+    /**
+     * The room re-seeded the document (`room.reseed.protocol`; the reason is
+     * the room's epoch): a refusal of this document, once a client with
+     * unsaved edits redialed and handed them over. The new epoch is a new
+     * document's. Also the answer to a copy the room cannot rebase (an
+     * epoch past the cuts it keeps, or a later one) and to an older epoch's
+     * content on a socket of the current one.
+     */
+    reseeded: 4410,
     /**
      * A room quota refused the socket's write (`quota: document`,
      * `quota: rate`, `quota: frame`): the frame was not applied, and a
@@ -425,13 +444,13 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
                 // (`discarded`) and reported the same way.
                 const update = decoding.readVarUint8Array(decoder);
                 const origin = emitSynced ? provider : (behavior.tabOrigin?.(provider) ?? provider);
-                const onError = (error) => provider.emit?.('message-error', [error, provider]);
+                const onError = (error) => fault(provider, error);
                 const { applied, problem, discarded } = syncProtocol.applyRemote(provider.doc, update, origin, onError);
                 const refused = problem ?? discarded;
                 if (refused) {
                     const docName = behavior.docName(provider);
                     provider.emit?.('schema-mismatch', [{ docName, problem: refused }, provider]);
-                    provider.emit?.('message-error', [new SchemaMismatchError(docName, refused), provider]);
+                    fault(provider, new SchemaMismatchError(docName, refused));
                 }
                 // Only an ACCEPTED Step2 is a held member state — a refused
                 // one never claims the handshake.
@@ -441,10 +460,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
                 return;
             }
             // Unknown sync subtype inside a valid envelope — observable.
-            provider.emit?.('message-error', [
-                new Error(`Unknown sync message type ${syncMessageType}`),
-                provider
-            ]);
+            unknownType(provider, 'sync', syncMessageType);
         },
         [messageQueryAwareness]: (encoder, _decoder, provider) => {
             encoding.writeVarUint(encoder, messageAwareness);
@@ -477,10 +493,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
         if (!messageHandler) {
             // Fail closed + observable: a VALID envelope carrying a message
             // type no handler claims is protocol skew — never silent.
-            provider.emit?.('message-error', [
-                new Error(`Unknown v14 message type ${messageType}`),
-                provider
-            ]);
+            unknownType(provider, 'v14', messageType);
             return encoder;
         }
         const followUp = messageHandler(encoder, decoder, provider, emitSynced);
@@ -503,7 +516,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
             catch (error) {
                 // same-tab publishes are delivered synchronously — a malformed
                 // message must not propagate into the publisher's call stack.
-                provider.emit?.('message-error', [error, provider]);
+                fault(provider, error);
             }
         };
     };
@@ -554,6 +567,21 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
     };
     /** The departure announcement — our presence, removed — on every transport the provider speaks. */
     const depart = (provider) => behavior.broadcast(provider, awarenessFrame(provider.awareness, [provider.doc.clientID], new Map()));
+    /**
+     * Wire `provider` to its room: its BroadcastChannel subscriber, `onUpdate`
+     * on its document's updates and its presence changes to the room
+     * (`awarenessUpdateHandler`). The teardown removes both listeners.
+     */
+    const listen = (provider, onUpdate) => {
+        provider._bcSubscriber = bcSubscriber(provider);
+        const onPresence = awarenessUpdateHandler(provider);
+        provider.doc.on('update', onUpdate);
+        provider.awareness.on('update', onPresence);
+        return () => {
+            provider.awareness.off('update', onPresence);
+            provider.doc.off('update', onUpdate);
+        };
+    };
     /** Leave the room: announce the presence removal, then unsubscribe the BC channel. */
     const disconnectBc = (provider) => {
         depart(provider);
@@ -572,6 +600,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
         hello,
         depart,
         connectBc,
-        disconnectBc
+        disconnectBc,
+        listen
     };
 };

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

@@ -174,6 +174,8 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
                 /** The room asks a read-only socket for its state again: what this actor wrote is unsaved until stored. */
                 allow(): void;
             };
+            /** @internal The room re-seeded: this document's unsaved edits are being handed over (`room.reseed.protocol`). */
+            _rebasing: boolean;
             messageHandlers: Record<number, RoomMessageHandler</*elided*/ any>>;
             hasSynced: boolean;
             whenSynced: Promise<unknown>;
@@ -185,22 +187,16 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
             /** Closes the current dial if it has not opened in time. */
             _connectTimer: ReturnType<typeof setTimeout> | undefined;
             _checkInterval: ReturnType<typeof setInterval>;
-            _updateHandler: (update: Uint8Array, origin: unknown, doc?: unknown, transaction?: {
-                local: boolean;
-            }) => void;
-            _awarenessUpdateHandler: (updates: {
-                added: number[];
-                updated: number[];
-                removed: number[];
-            }, origin: unknown) => void;
+            /** @internal Removes the document and presence listeners (`room.listen`). */
+            _unlisten: () => void;
             /**
              * The dial URL: the room name as one encoded path segment (any id —
              * `/`, `%`, `#`, `?` included — reaches its own room; the server
              * decodes it). `''`, `.`, `..`, an id over 256 characters and one with a
              * lone surrogate are refused at construction ({@link assertRoomId}). `params` are read at every dial (a refreshed token
              * reaches the next connection), with `replica` = this document's
-             * client id unless `params` names one: the room binds the socket's
-             * writes to it.
+             * client id unless `params` names one (the room binds the socket's
+             * writes to it), and `epoch`, the document's, which no param replaces.
              */
             get url(): string;
             /** Updates of this document's actor the room has not acknowledged as persisted yet. */
@@ -223,11 +219,11 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
             destroy(): void;
             disconnect(): void;
             connect(): void;
-            emit<N extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
+            emit<N extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<WebsocketProviderEvents[N]>): void;
             _observers: Map<string, Set<any>>;
-            on<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
-            once<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
-            off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            on<NAME extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): WebsocketProviderEvents[NAME];
+            once<NAME extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
+            off<NAME extends "refused" | "status" | "failed" | "message-error" | "schema-mismatch" | "protocol-mismatch" | "synced" | "access" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
         };
     };
     watchComments: (server: string | null, roomName: string, listener: (message: CommentMessage) => void) => (() => void);

package/dist/crdt/providers/websocket.js

@@ -47,18 +47,19 @@
  * there (TCP never does).
  */
 import * as decoding from 'lib0-v14/decoding';
+import * as encoding from 'lib0-v14/encoding';
 import * as time from 'lib0-v14/time';
 import * as math from 'lib0-v14/math';
 import * as url from 'lib0-v14/url';
 import { Awareness, removeAwarenessStates } from '../protocols/awareness.js';
 import { IsolatedObservable } from '../protocols/observable.js';
-import { messagePermissionDenied, messageAccess, messageReadOnly, READ_ONLY_DENIAL, SUGGEST_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
+import { messagePermissionDenied, messageAccess, messageEpoch, messageReadOnly, READ_ONLY_DENIAL, SUGGEST_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
 import { bindSync } from '../protocols/sync.js';
 import { readCommentsMessage, writeCommentsSubscribe } from '../protocols/comments.js';
 import { frame } from '../protocols/envelope.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 { assertRoomId, beginDestroy, bindRoomProtocol, tabs, chunkFrame, CLOSE, createChunkReader, emitFailed, fault, initLifecycle, isRefusal, unknownType, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageRebase, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
 import { asEngineDoc } from '../structs.js';
-import { ATTRIBUTION_ROOT } from '../schema.js';
+import { ATTRIBUTION_ROOT, EPOCH_ROOT } from '../schema.js';
 import { ATTRIBUTION_ORIGIN, writerOf } from '../attribution/attribution.js';
 // @todo - this should depend on awareness.outdatedTime
 const messageReconnectTimeout = 30000;
@@ -129,16 +130,20 @@ export const bindWebsocketProvider = (Y) => {
                 // The room's notice at the join: a state, not a refusal (no event).
                 () => provider._writes.deny(), 
                 // The room's word at the join, and at a change in place (`read`).
-                (access) => provider.emit('access', [access, provider]));
+                (access) => provider.emit('access', [access, provider]), 
+                // The room re-seeded since this document's epoch: it asks for the
+                // document, its unsaved edits in it (`room.reseed.protocol`).
+                () => {
+                    provider._rebasing = true;
+                    send(provider, frame(messageRebase, (e) => encoding.writeVarUint8Array(e, Y.encodeStateAsUpdate(provider.doc))));
+                });
                 if (authType !== messagePermissionDenied &&
                     authType !== messageReadOnly &&
-                    authType !== messageAccess) {
+                    authType !== messageAccess &&
+                    authType !== messageEpoch) {
                     // An auth type we do not speak inside a valid v14 envelope is
                     // protocol skew — reported, never dropped silently.
-                    provider.emit('message-error', [
-                        new Error(`Unknown auth message type ${authType}`),
-                        provider
-                    ]);
+                    unknownType(provider, 'auth', authType);
                 }
             }
         },
@@ -403,6 +408,13 @@ export const bindWebsocketProvider = (Y) => {
                 provider.awareness.meta.delete(client);
             provider.emit('status', [{ status: 'disconnected' }]);
         }
+        // A re-seed (`room.reseed.protocol`): unsaved edits are handed over first,
+        // by a dial of this document's epoch, older now, which the room asks for
+        // them. Then, or with none, it is a refusal: the new epoch is a new document's.
+        if (event?.code === CLOSE.reseeded && provider.unsaved > 0 && !provider._rebasing) {
+            provider._rebasing = true;
+            return setupWS(provider);
+        }
         if (event && isRefusal(event.code)) {
             // Terminal: the next dial would be refused the same way.
             provider.shouldConnect = false;
@@ -459,7 +471,7 @@ export const bindWebsocketProvider = (Y) => {
                     room.readMessage(provider, new Uint8Array(event.data), true, (buf) => sendOn(provider, websocket, buf));
                 }
                 catch (error) {
-                    provider.emit('message-error', [error, provider]);
+                    fault(provider, error);
                 }
             };
             websocket.onerror = (event) => {
@@ -514,6 +526,8 @@ export const bindWebsocketProvider = (Y) => {
         _chunks = createChunkReader();
         /** This actor's writes pending the room's acknowledgement. */
         _writes;
+        /** @internal The room re-seeded: this document's unsaved edits are being handed over (`room.reseed.protocol`). */
+        _rebasing = false;
         messageHandlers = room.messageHandlers;
         // The room lifecycle — installed by `initLifecycle`.
         hasSynced;
@@ -526,8 +540,8 @@ export const bindWebsocketProvider = (Y) => {
         /** Closes the current dial if it has not opened in time. */
         _connectTimer;
         _checkInterval;
-        _updateHandler;
-        _awarenessUpdateHandler;
+        /** @internal Removes the document and presence listeners (`room.listen`). */
+        _unlisten;
         constructor(serverUrl, roomname, doc, { connect = true, awareness = new Awareness(doc), params = {}, WebSocketPolyfill = WebSocket, resyncInterval = 0, maxBackoffTime = 2500, connectTimeout = defaultConnectTimeout, disableBc = false, maxFrameBytes = MAX_FRAME_BYTES } = {}) {
             assertRoomId(roomname);
             super();
@@ -548,14 +562,13 @@ export const bindWebsocketProvider = (Y) => {
             if (resyncInterval > 0) {
                 this._resync = setInterval(() => send(this, room.step1(this)), resyncInterval);
             }
-            this._bcSubscriber = room.bcSubscriber(this);
             providers.add(this);
             // Local doc updates go to the room; another tab's go to the server
             // only (`broadcastUpdate` quarantines a read-only document). A
             // socket the room made read-only gets this document's own edits
             // alone (each is denied): what a tab or a store delivered, and the
             // actor records, would draw denials nobody made.
-            this._updateHandler = (update, origin, _doc, transaction) => {
+            const onUpdate = (update, origin, _doc, transaction) => {
                 if (origin === this)
                     return;
                 const heard = origin === this._fromTab;
@@ -573,9 +586,7 @@ export const bindWebsocketProvider = (Y) => {
             };
             this._writes = new OwnWrites(doc, (unsaved) => this.emit('saved', [{ saved: unsaved === 0, unsaved }, this]));
             this._writes.trackDocument();
-            this.doc.on('update', this._updateHandler);
-            this._awarenessUpdateHandler = room.awarenessUpdateHandler(this);
-            awareness.on('update', this._awarenessUpdateHandler);
+            this._unlisten = room.listen(this, onUpdate);
             this._checkInterval = setInterval(() => {
                 if (!this.wsconnected)
                     return;
@@ -602,12 +613,22 @@ export const bindWebsocketProvider = (Y) => {
          * decodes it). `''`, `.`, `..`, an id over 256 characters and one with a
          * lone surrogate are refused at construction ({@link assertRoomId}). `params` are read at every dial (a refreshed token
          * reaches the next connection), with `replica` = this document's
-         * client id unless `params` names one: the room binds the socket's
-         * writes to it.
+         * client id unless `params` names one (the room binds the socket's
+         * writes to it), and `epoch`, the document's, which no param replaces.
          */
         get url() {
-            const query = url.encodeQueryParams({ replica: String(this.doc.clientID), ...this.params });
-            return `${this.serverUrl}/${encodeURIComponent(this.roomname)}?${query}`;
+            // The document's epoch (`new`: it holds nothing yet), which the room checks (`room.reseed.protocol`).
+            const epoch = this.doc.store.clients.size
+                ? String(asEngineDoc(this.doc).get(EPOCH_ROOT).getAttr('n') ?? 0)
+                : 'new';
+            const query = {
+                replica: String(this.doc.clientID),
+                epoch,
+                ...this.params
+            };
+            // In its place, but no param of the app's names it instead.
+            query.epoch = epoch;
+            return `${this.serverUrl}/${encodeURIComponent(this.roomname)}?${url.encodeQueryParams(query)}`;
         }
         /** Updates of this document's actor the room has not acknowledged as persisted yet. */
         get unsaved() {
@@ -651,8 +672,7 @@ export const bindWebsocketProvider = (Y) => {
             clearInterval(this._checkInterval);
             providers.delete(this);
             this.disconnect();
-            this.awareness.off('update', this._awarenessUpdateHandler);
-            this.doc.off('update', this._updateHandler);
+            this._unlisten();
             super.destroy();
         }
         disconnect() {

package/dist/crdt/rangeDelete.d.ts

@@ -1,48 +1,8 @@
 /**
- * Range deletion between two positions — one prepared document operation
- * whose merge is the document's `canMerge`. The rules are the
- * `del.range.*` rows of `docs/editor-delete-contract.md`:
- *
- * - the head keeps `[0, start)`, the tail keeps `[end, len)`, and every
- *   block strictly between them in document order dies;
- * - the head dies iff its prefix is empty (never for a replacement,
- *   `del.range.replace`, nor when nothing else would be left to hold the
- *   caret, `del.range.whole-doc`: the head is kept, emptied, with its id,
- *   type and data, so peers deleting the same range keep the same block)
- *   and the tail then keeps its id; the tail dies iff
- *   its suffix is empty; otherwise the tail's suffix merges into the head
- *   when `canMerge(tail, head)` allows it (`del.range.island-seal`) — an end
- *   at the tail's start included: the seam between them is deleted;
- * - what follows the range end survives: the dying tail's children and the
- *   later siblings inside every container the range dies through take the
- *   topmost such container's slot, unless that would cross an island seal —
- *   then those containers stay (`del.range.outside-survives`);
- * - a container (a list: the document's `isContainer`) never dies because
- *   the range starts before it: it keeps what follows the range end, like
- *   the keys (`del.merge.container`); it dies only when it loses every
- *   child and holds no text of its own — the document's `emptiable`, the
- *   keys' rule (`del.range.empty-container`). An island that renders
- *   no content dies when it loses every child too, except a `lines` island
- *   (a code block) the range lies in: its head is then kept, emptied
- *   (`del.range.island-kept`);
- * - what a range rescues takes the kind it shows in its new slot (the
- *   document's `settle`: a paragraph rescued into a list is its item);
- * - blocks the view hides (a closed toggle's body) are not in the range:
- *   they go only with a block that goes, so a surviving head keeps its
- *   hidden children, unless it is kept only to hold the caret; a dying
- *   closed tail's body takes its place, shown (`del.range.hidden-body`);
- * - a layout the range leaves with one column dissolves, in the same plan
- *   (`layout.dissolving`);
- * - a range with an end in a table's cell keeps every cell and row: each
- *   cell it crosses loses the text it covers, nothing merges across a
- *   cell's edge, the blocks outside the table between the ends go, a
- *   table wholly between them goes whole, and the caret lands at the start
- *   (`table.range`);
- * - the plan's `at` is where the caret lands (`del.range.caret`).
+ * The types range deletion (`deleteRange`, `replaceRange`: the `del.range.*`
+ * rows, prepared in `doc/ops.ts`) reads.
  */
 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;
@@ -56,8 +16,3 @@ export type DocPosition = {
 export type RangeView = {
     hidden?: (id: BlockId, removed?: ReadonlySet<BlockId>) => boolean;
 };
-/** `deleteRange` and `replaceRange` (the head kept), prepared. */
-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,169 +1 @@
-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.
-    const prepare = (keepHead, headSpent = false) => (from, to, view = {}) => {
-        // 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 = 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.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;
-        const E = e.block;
-        if (S === E) {
-            const length = e.offset - s.offset;
-            const writes = length > 0 ? [{ op: 'deleteText', id: S, offset: s.offset, length }] : [];
-            return { ...c.plan([S], writes), at: s };
-        }
-        const parent = (id) => c.ancestorsOf(id)[0] ?? null;
-        const chain = c.ancestorsOf(E);
-        if (c.isTableCell(S) || c.isTableCell(E))
-            return inTables(s, e, view);
-        // What the view hides once `removed` go (nothing: as it is now).
-        const hiddenOnce = (removed) => {
-            const set = new Set(removed);
-            return (id) => !!view.hidden?.(id, set);
-        };
-        const headDies = !keepHead && s.offset === 0;
-        // What the view hides is not in the range: it goes only with a block that goes,
-        // a dying head's body included.
-        const hidden = hiddenOnce(headDies || headSpent ? [S] : []);
-        const between = ids.slice(at.get(S) + 1, at.get(E)).filter((id) => !hidden(id));
-        const lenE = c.displayLength(E);
-        const tailDies = e.offset === lenE;
-        const merges = !headDies && !tailDies && c.canMerge(E, S);
-        const tailGone = tailDies || merges;
-        // E's ancestors the range starts before die unless the rescue would cross an island.
-        // A container (a list) is not one: it dies only when the range empties it, and
-        // keeps its later items like the keys do (`del.merge.container`).
-        const partial = chain.filter((a) => (a === (headDies ? S : null) || between.includes(a)) && !c.isContainer(a));
-        const top = partial.at(-1);
-        const sealed = top !== undefined && chain.slice(0, chain.indexOf(top) + 1).some(c.isIsland);
-        const spared = new Set(sealed ? chain : []);
-        const doomed = new Set(between.filter((id) => !spared.has(id) && !chain.includes(id)));
-        if (!sealed)
-            partial.forEach((a) => doomed.add(a));
-        if (headDies && !spared.has(S))
-            doomed.add(S);
-        if (tailDies)
-            doomed.add(E);
-        // Rescue what follows the range end right after the topmost dying container's slot
-        // (after, not at it: a concurrent delete of S revives a merged E above them).
-        const home = sealed || top === undefined ? (tailGone ? E : undefined) : top;
-        const rescued = home === undefined ? [] : tailGone ? c.childrenIds(E) : [E];
-        for (let cur = E; home !== undefined && cur !== home; cur = parent(cur)) {
-            const sibs = c.childrenIds(parent(cur));
-            rescued.push(...sibs.slice(sibs.indexOf(cur) + 1));
-        }
-        const dest = home === undefined || rescued.length === 0 ? null : c.positionOf(home);
-        // A container (or an island that renders nothing) losing every child dies too.
-        const gone = (id) => doomed.has(id) || (merges && id === E);
-        const dies = (id) => c.emptiable(id) || (c.isIsland(id) && !c.rendersContent(id));
-        const emptied = (id) => {
-            if (id === null || gone(id) || !dies(id) || id === dest?.parent)
-                return;
-            if (!c.childrenIds(id).every(gone))
-                return;
-            doomed.add(id);
-            emptied(parent(id));
-        };
-        [...doomed, ...(merges ? [E] : [])].forEach((id) => emptied(parent(id)));
-        // A range inside one `lines` island never removes it: the head stays, emptied
-        // (a code block's Mod+A, `del.range.island-kept`).
-        const island = c.ancestorsOf(S).find(c.isIsland);
-        const linesIsland = island !== undefined && c.isLines(island);
-        if (!keepHead && linesIsland && doomed.has(island) && chain.includes(island))
-            return prepare(true, headDies)(from, to, view);
-        const lenS = c.displayLength(S);
-        const writes = [];
-        if (!doomed.has(S) && lenS > s.offset)
-            writes.push({ op: 'deleteText', id: S, offset: s.offset, length: lenS - s.offset });
-        if (!gone(E) && e.offset > 0)
-            writes.push({ op: 'deleteText', id: E, offset: 0, length: e.offset });
-        if (dest !== null) {
-            writes.push(...c.move(rescued, dest.parent, dest.index + 1));
-            // Each shows the kind of its new slot (an island's line, a list's item leave theirs).
-            for (const id of rescued)
-                writes.push(...c.settle(parent(id), [id], dest.parent));
-        }
-        if (merges) {
-            // The whole tail merges, then its cut prefix goes: E's own text is never written.
-            writes.push({ op: 'mergeBlocks', from: E, into: S, at: s.offset, length: lenE });
-            if (e.offset > 0)
-                writes.push({ op: 'deleteText', id: S, offset: s.offset, length: e.offset });
-        }
-        const kept = [...rescued, ...(merges ? [E] : [])];
-        for (const id of doomed)
-            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(new Set([...doomed, ...(merges ? [E] : [])]), rescued, writes));
-        const caret = (() => {
-            if (!doomed.has(S))
-                return s;
-            if (!gone(E))
-                return { block: E, offset: 0 };
-            const survives = (id) => id === null || rescued.includes(id) || (!gone(id) && survives(parent(id)));
-            // Shown once the plan runs: a dying closed tail's rescued body is.
-            const hiddenAfter = hiddenOnce([...doomed, ...(merges ? [E] : [])]);
-            const shown = (id) => survives(id) && holds(id) && !hiddenAfter(id);
-            // Before the tail: blocks a sealed rescue spared between S and E count too.
-            const prev = ids.slice(0, at.get(E)).findLast(shown);
-            if (prev !== undefined)
-                return { block: prev, offset: c.displayLength(prev) };
-            const next = ids.slice(at.get(E) + 1).find(shown);
-            return next === undefined ? null : { block: next, offset: 0 };
-        })();
-        // Nothing else left to hold the caret: the head stays, emptied (whole-doc).
-        if (caret === null)
-            return prepare(true, headDies)(from, to, view);
-        return { ...c.plan([caret.block], writes), at: caret };
-    };
-    /**
-     * `table.range`: a range with an end in a cell. Every cell it crosses
-     * loses the text it covers and stays, with its row; the ends keep what
-     * lies outside the range, merging nothing; any other block between the
-     * ends goes (a table wholly between them whole), but the ancestors of
-     * the end, which stay and lose their text (the range covers it: they
-     * come after the start in reading order); the caret lands at the start.
-     */
-    const inTables = (s, e, view) => {
-        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));
-        const writes = [];
-        const lenS = c.displayLength(S);
-        if (lenS > s.offset)
-            writes.push({ op: 'deleteText', id: S, offset: s.offset, length: lenS - s.offset });
-        const [tableS, tableE] = [c.tableOf(S), c.tableOf(E)];
-        const doomed = new Set();
-        for (const id of between) {
-            const table = c.tableOf(id);
-            if (kept.has(id) || (table !== null && (table === tableS || table === tableE))) {
-                const len = c.isTableCell(id) || kept.has(id) ? c.displayLength(id) : 0;
-                if (len > 0)
-                    writes.push({ op: 'deleteText', id, offset: 0, length: len });
-            }
-            else
-                doomed.add(id);
-        }
-        if (e.offset > 0)
-            writes.push({ op: 'deleteText', id: E, offset: 0, length: e.offset });
-        const parentOf = (id) => c.ancestorsOf(id)[0] ?? null;
-        const roots = [...doomed].filter((id) => !doomed.has(parentOf(id)));
-        for (const id of roots)
-            writes.push(c.remove(id, []));
-        writes.push(...c.dissolving(new Set(roots), [], writes));
-        return { ...c.plan([S], writes), at: s };
-    };
-    return { deleteRange: prepare(false), replaceRange: prepare(true) };
-};
+export {};