edytor 4.0.0 → 6.0.0

package/dist/crdt/providers/room.js

@@ -293,6 +293,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
@@ -425,13 +429,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 +445,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 +478,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 +501,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 +552,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 +585,7 @@ export const bindRoomProtocol = (syncProtocol, behavior) => {
         hello,
         depart,
         connectBc,
-        disconnectBc
+        disconnectBc,
+        listen
     };
 };

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

@@ -7,6 +7,8 @@ export type WebsocketProviderEvents = {
     status: (event: {
         status: 'connected' | 'disconnected' | 'connecting';
     }) => void;
+    /** What the room says this connection's user may do, as it joins (and at a change in place). */
+    access: (access: 'write' | 'suggest' | 'comment' | 'read', provider: unknown) => void;
     synced: (state: boolean) => void;
     'connection-close': (event: CloseEvent | null, provider: unknown) => void;
     'connection-error': (event: Event, provider: unknown) => void;
@@ -183,14 +185,8 @@ 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
@@ -221,11 +217,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" | "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" | "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" | "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" | "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

@@ -52,11 +52,11 @@ 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, messageReadOnly, READ_ONLY_DENIAL, readAuthMessage } from '../protocols/auth.js';
+import { messagePermissionDenied, messageAccess, 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, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
 import { asEngineDoc } from '../structs.js';
 import { ATTRIBUTION_ROOT } from '../schema.js';
 import { ATTRIBUTION_ORIGIN, writerOf } from '../attribution/attribution.js';
@@ -122,18 +122,20 @@ export const bindWebsocketProvider = (Y) => {
                     if (readOnly)
                         provider._writes.deny();
                     provider.emit('permission-denied', [reason, provider]);
-                    if (!readOnly)
+                    // What a suggest-only socket may not write is stripped: the socket stays.
+                    if (!readOnly && reason !== SUGGEST_ONLY_DENIAL)
                         emitFailed(provider, new Error(`permission denied: ${reason}`));
                 }, 
                 // The room's notice at the join: a state, not a refusal (no event).
-                () => provider._writes.deny());
-                if (authType !== messagePermissionDenied && authType !== messageReadOnly) {
+                () => provider._writes.deny(), 
+                // The room's word at the join, and at a change in place (`read`).
+                (access) => provider.emit('access', [access, provider]));
+                if (authType !== messagePermissionDenied &&
+                    authType !== messageReadOnly &&
+                    authType !== messageAccess) {
                     // 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);
                 }
             }
         },
@@ -454,7 +456,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) => {
@@ -521,8 +523,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();
@@ -543,14 +545,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;
@@ -568,9 +569,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;
@@ -646,8 +645,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/purge.d.ts

@@ -18,6 +18,7 @@
 import type { EngineApi, EngineDoc } from './engine-api.js';
 import { type PlacementModel } from './placement/model.js';
 import { type TextEngine } from './text/model.js';
+import { type SuggestFacade } from './doc/suggest.js';
 /** The horizon: the time and encoded state vector of the room's epoch (`room.purge.timing`). */
 export type Horizon = {
     at: number;
@@ -43,6 +44,11 @@ export type PurgeReport = {
     merged: number;
     /** Release records the horizon covers (`hist.release.end`): deleted. */
     released: number;
+    /**
+     * Suggestions decided before the horizon (`sugg.purge`): nothing of them
+     * pending, their records' entries older than it: their records deleted.
+     */
+    suggestions: number;
 };
 /**
  * The ended histories a document holds (`hist.release.end`): per writer,
@@ -53,7 +59,7 @@ export declare const releasesOf: (doc: EngineDoc) => Map<number, number>;
 /** The horizon a document holds (`null`: never purged). */
 export declare const readHorizon: (doc: EngineDoc) => Horizon | null;
 export declare const bindPurge: (Y: EngineApi) => {
-    purge: (doc: EngineDoc, facade: {
+    purge: (doc: EngineDoc, facade: Partial<SuggestFacade> & {
         model: PlacementModel;
         text: TextEngine;
     }, horizon: Horizon | null) => PurgeReport;

package/dist/crdt/purge.js

@@ -1,10 +1,13 @@
 import { recordsOf, registryOf, view as modelView } from './placement/model.js';
 import { removeUnit, unitOf } from './placement/slots.js';
 import { deleteClaims, purgeStreams, scanText } from './text/model.js';
-import { BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, REGISTRY_KEY, RELEASE_ROOT, TEXT_DELETES_ROOT, WITHDRAW_PREFIX } from './schema.js';
+import { BLOCK_ATTR_ROOT, DATA, DATA_LEAF_PREFIX, DEL_PREFIX, HORIZON_ATTR, HORIZON_ROOT, REGISTRY_KEY, RELEASE_ROOT, SUGGEST_ROOT, TEXT_DELETES_ROOT, WITHDRAW_PREFIX } from './schema.js';
 import { baseIdOf, isIncarnationId } from './incarnations.js';
+import { suggestionsOf } from './doc/suggest.js';
 import { attrItems, dropSearchMarkers, engineOps, firstItem, holdsIds } from './structs.js';
 const mapOf = (node) => attrItems(node);
+/** The clock a suggestion's record opened at (its writer's clocks it owns start there). */
+const clockOf = (rec) => rec.start ?? 0;
 /**
  * The ended histories a document holds (`hist.release.end`): per writer,
  * the clock its latest live release record ended at (what it wrote below
@@ -107,7 +110,8 @@ export const bindPurge = (Y) => {
             records: 0,
             claims: 0,
             merged: 0,
-            released: 0
+            released: 0,
+            suggestions: 0
         };
         const vector = horizon === null
             ? new Map()
@@ -425,6 +429,32 @@ export const bindPurge = (Y) => {
                 report.released++;
             }
         }
+        // Suggestions decided before the horizon (`sugg.purge`): the decision
+        // trail goes with them. A writer's oldest record first, so no record's
+        // clocks pass to another.
+        const suggest = facade.part && suggestionsOf(facade);
+        const records = suggest?.records() ?? [];
+        if (records.length > 0) {
+            const pending = new Set(suggest.changes().map((c) => c.suggestion));
+            const root = doc.get(SUGGEST_ROOT);
+            const seen = new Set();
+            for (const rec of [...records].sort((a, b) => clockOf(a) - clockOf(b))) {
+                if (seen.has(rec.writer))
+                    continue;
+                seen.add(rec.writer);
+                const node = root.getAttr(rec.id);
+                const items = [node._item];
+                for (let it = firstItem(node); it; it = it.right)
+                    if (!it.deleted)
+                        items.push(it);
+                if (pending.has(rec.id) ||
+                    !items.every((it) => old(it.id.client, it.id.clock + it.length - 1)))
+                    continue;
+                root.deleteAttr(rec.id);
+                seen.delete(rec.writer);
+                report.suggestions++;
+            }
+        }
         // The horizon record, last.
         if (horizon !== null)
             doc.get(HORIZON_ROOT).setAttr(HORIZON_ATTR, { at: horizon.at, sv: horizon.sv });

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 {};

package/dist/crdt/restore.d.ts

@@ -26,6 +26,7 @@
 import type { EngineDoc } from './engine-api.js';
 import { type BlockId, type ContentItem, type InlineSpec, type PlacementModel } from './placement/model.js';
 import type { DataPatch } from './data.js';
+import { type SuggestFacade } from './doc/suggest.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 = {
@@ -60,7 +61,7 @@ export type RestoreReport = {
     deleted: number;
 };
 /** What a restore reads and writes through: the facade over the document (structurally). */
-export type RestoreFacade<Plan> = {
+export type RestoreFacade<Plan> = Partial<SuggestFacade> & {
     model: PlacementModel;
     childSlots(parent: BlockId | null): readonly {
         id: BlockId;

package/dist/crdt/restore.js

@@ -1,4 +1,5 @@
 import { blockNodeOf, insertSpecsAt, moveBlocksTo, view as modelView } from './placement/model.js';
+import { suggestionsOf } from './doc/suggest.js';
 import { DEL_PREFIX, TYPE, WITHDRAW_PREFIX } from './schema.js';
 import { common, patchWrites, writeData } from './data.js';
 import { canonKey, deleteClaims } from './text/model.js';
@@ -196,5 +197,13 @@ export const restoreDocument = (doc, facade, json) => {
     }
     // 6 · The document's data.
     facade.apply(facade.prepare.patchData(null, [{ path: [], value: json.data ?? {} }]));
+    // 7 · Pending suggestions are dropped (`sugg.restore`): the version holds
+    // none (its document without them), so what the restore left of them —
+    // their proposals — is rejected, in the restore's step (its undo brings
+    // them back).
+    // (Built over the facade, its shared suggestions: `doc/suggest.ts`.)
+    const suggest = facade.part && suggestionsOf(facade);
+    if (suggest)
+        suggest.run(suggest.decide(suggest.changes(), false));
     return report;
 };

package/dist/crdt/schema.d.ts

@@ -49,6 +49,14 @@ export declare const HORIZON_ATTR = "h";
  * horizon covers.
  */
 export declare const RELEASE_ROOT = "released";
+/**
+ * The shared suggestions (`crdt/doc/suggest.ts`): attr `<id>` is one
+ * suggestion's record node, written by its writer (a client id bound to its
+ * author): its creation time `at`, `via` and `lbl`, and a list of id lists
+ * (fork patch YP31: its writer's proposed deletions, anyone else's settled
+ * ranges) and proposed operations. In the history's scope.
+ */
+export declare const SUGGEST_ROOT = "suggest";
 /** Named node roles (`SCHEMA.nodes`). */
 export declare const BLOCK_NODE = "block";
 export declare const CONTENT_NODE = "content";
@@ -92,7 +100,7 @@ export declare const LAST_CHANGED_ATTR = "l";
 export declare const CONTENT = "content";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
-    readonly version: 10;
+    readonly version: 11;
     readonly name: "edytor-doc";
     readonly roots: {
         readonly registry: "blocks";

package/dist/crdt/schema.js

@@ -42,6 +42,14 @@ export const HORIZON_ATTR = 'h';
  * horizon covers.
  */
 export const RELEASE_ROOT = 'released';
+/**
+ * The shared suggestions (`crdt/doc/suggest.ts`): attr `<id>` is one
+ * suggestion's record node, written by its writer (a client id bound to its
+ * author): its creation time `at`, `via` and `lbl`, and a list of id lists
+ * (fork patch YP31: its writer's proposed deletions, anyone else's settled
+ * ranges) and proposed operations. In the history's scope.
+ */
+export const SUGGEST_ROOT = 'suggest';
 /** Named node roles (`SCHEMA.nodes`). */
 export const BLOCK_NODE = 'block';
 export const CONTENT_NODE = 'content';
@@ -86,9 +94,11 @@ export const SCHEMA = {
     // YP21), a block has no `claims` list; 9: a block's place is its home slot
     // in its parent's sequence and a move is a move record (fork patch YP22),
     // a block has no `at` map and an array item no rank; 10: the update encoding
-    // writes each distinct string once (fork patch YP24). A container or frame
-    // of an earlier generation is refused.
-    version: 10,
+    // writes each distinct string once (fork patch YP24); 11: a hold record
+    // inside a nested node holds nothing (fork patch YP31: a suggestion's
+    // proposals and decisions). A container or frame of an earlier generation
+    // is refused.
+    version: 11,
     name: 'edytor-doc',
     roots: { registry: REGISTRY_KEY, meta: META_ROOT_KEY },
     metaAttrs: { version: 'v', schema: 'schema' }