edytor 2.0.0 → 4.0.0

package/dist/crdt/providers/websocket.js

@@ -59,7 +59,7 @@ 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 { asEngineDoc } from '../structs.js';
 import { ATTRIBUTION_ROOT } from '../schema.js';
-import { ATTRIBUTION_ORIGIN } from '../attribution/attribution.js';
+import { ATTRIBUTION_ORIGIN, writerOf } from '../attribution/attribution.js';
 // @todo - this should depend on awareness.outdatedTime
 const messageReconnectTimeout = 30000;
 /** Silence after which the socket is sent one text `ping` (a room auto-answers `pong`). */
@@ -142,16 +142,16 @@ export const bindWebsocketProvider = (Y) => {
             provider.synced = true;
         }
     });
-    // A room's comment threads (`watchComments`): the listeners of each room,
-    // by `<serverUrl>/<room>`, and the providers dialing it. A provider asks
-    // the room for them (a subscribe) at every open while a room has a
-    // listener, and hands each message the room sends to every listener.
-    const commentListeners = new Map();
-    const providersOf = new Map();
+    const watchers = new Set();
+    const providers = new Set();
     const subscribeFrame = (on) => frame(messageComments, (e) => writeCommentsSubscribe(e, on));
+    const hears = (watcher, provider) => watcher.room === provider.roomname &&
+        (watcher.channel === null || watcher.channel === provider.bcChannel);
+    const listenersOf = (provider) => [...watchers].filter((watcher) => hears(watcher, provider)).map((watcher) => watcher.listener);
+    const providersFor = (watcher) => [...providers].filter((p) => hears(watcher, p));
     room.messageHandlers[messageComments] = (_encoder, decoder, provider) => {
         const message = readCommentsMessage(decoder);
-        for (const listener of [...(commentListeners.get(provider.bcChannel) ?? [])]) {
+        for (const listener of listenersOf(provider)) {
             try {
                 listener(message);
             }
@@ -162,26 +162,28 @@ export const bindWebsocketProvider = (Y) => {
     };
     /**
      * Hear the comment threads of `room` on `server` (the URL a provider
-     * dials, `ws:`/`wss:`): every provider of that room subscribes now and
-     * at each (re)connect, which the room answers with every thread (a
-     * `snapshot`), then sends each `change`. Answers the unsubscribe; the
-     * last one leaving tells the room to stop.
+     * dials, `ws:`/`wss:`; `null`: every provider of that room on the page,
+     * whatever its server): every such provider subscribes now and at each
+     * (re)connect, which the room answers with every thread (a `snapshot`),
+     * then sends each `change`. Answers the unsubscribe; the last listener
+     * of a provider leaving tells its room to stop.
      */
     const watchComments = (server, roomName, listener) => {
-        const key = `${server.replace(/\/+$/, '')}/${roomName}`;
-        const listeners = commentListeners.get(key) ?? new Set();
-        commentListeners.set(key, listeners);
-        const first = listeners.size === 0;
-        listeners.add(listener);
-        if (first)
-            for (const provider of providersOf.get(key) ?? [])
-                send(provider, subscribeFrame(true));
+        const watcher = {
+            room: roomName,
+            channel: server === null ? null : `${server.replace(/\/+$/, '')}/${roomName}`,
+            listener
+        };
+        const fresh = providersFor(watcher).filter((p) => listenersOf(p).length === 0);
+        watchers.add(watcher);
+        for (const provider of fresh)
+            send(provider, subscribeFrame(true));
         return () => {
-            if (!listeners.delete(listener) || listeners.size > 0)
+            if (!watchers.delete(watcher))
                 return;
-            commentListeners.delete(key);
-            for (const provider of providersOf.get(key) ?? [])
-                send(provider, subscribeFrame(false));
+            for (const provider of providersFor(watcher))
+                if (listenersOf(provider).length === 0)
+                    send(provider, subscribeFrame(false));
         };
     };
     // The room's acknowledgement and its bounded catch-up (a frame too large
@@ -260,10 +262,12 @@ export const bindWebsocketProvider = (Y) => {
      * reload, its other tabs), and a seed writer (content any replica may
      * write, never stripped). Another actor's structs are not this replica's
      * to save: a room restored from a lagging snapshot strips them for good.
-     * A doc without a binding for its own id (a raw doc) owns all.
+     * The actor is the binding of the doc's own id, written with its first
+     * write, and before it the actor the document attached (`writerOf`). A
+     * raw doc, with neither, owns all.
      */
     const ownerOf = (doc) => {
-        const actor = actorOf(doc, doc.clientID);
+        const actor = writerOf(asEngineDoc(doc));
         return (client) => actor === undefined ||
             client === doc.clientID ||
             client < seedBand ||
@@ -468,7 +472,7 @@ export const bindWebsocketProvider = (Y) => {
                 for (const buf of room.hello(provider))
                     sendOn(provider, websocket, buf);
                 // The room's comment threads, while someone listens (`watchComments`).
-                if (commentListeners.get(provider.bcChannel)?.size)
+                if (listenersOf(provider).length > 0)
                     sendOn(provider, websocket, subscribeFrame(true));
             };
             provider.emit('status', [{ status: 'connecting' }]);
@@ -540,8 +544,7 @@ export const bindWebsocketProvider = (Y) => {
                 this._resync = setInterval(() => send(this, room.step1(this)), resyncInterval);
             }
             this._bcSubscriber = room.bcSubscriber(this);
-            const peers = providersOf.get(this.bcChannel) ?? new Set();
-            providersOf.set(this.bcChannel, peers.add(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
@@ -641,9 +644,7 @@ export const bindWebsocketProvider = (Y) => {
                 return;
             clearInterval(this._resync);
             clearInterval(this._checkInterval);
-            const peers = providersOf.get(this.bcChannel);
-            if (peers?.delete(this) && peers.size === 0)
-                providersOf.delete(this.bcChannel);
+            providers.delete(this);
             this.disconnect();
             this.awareness.off('update', this._awarenessUpdateHandler);
             this.doc.off('update', this._updateHandler);

package/dist/crdt/purge.d.ts

@@ -9,8 +9,11 @@
  * The horizon is a state vector: an item whose clock is below it was
  * stored by the room before the horizon's time (`room.purge.timing`). A
  * deletion's time is the struct that made it: a block's oldest live delete
- * mark (a withdrawn block: its withdraw mark, and the marks of what it last
- * held), a text delete mark record, a placement candidate.
+ * mark (a withdrawn block: its withdraw mark, and the records of what it last
+ * held), a text hold record, a move record. A delete of a session whose
+ * history ended (a release record, `hist.release.end`) is past the horizon
+ * whatever its time: a delete or withdraw mark, a text hold record of that
+ * writer below the record's clock. A move or a merge waits for the horizon.
  */
 import type { EngineApi, EngineDoc } from './engine-api.js';
 import { type PlacementModel } from './placement/model.js';
@@ -24,14 +27,12 @@ export type Horizon = {
 export type PurgeReport = {
     /** Blocks removed: registry entry deleted, node collected. */
     removed: number;
-    /** Deleted blocks kept (they delimit a live text, or a block is placed under them) whose stream, data and claims were deleted. */
+    /** Deleted blocks kept (a live block streams in their text, two boundaries name them, or a block is placed under them) whose stream, data and claims were deleted. */
     emptied: number;
-    /** Text delete mark records deleted. */
+    /** Text hold records deleted (what they held deleted with them). */
     marks: number;
-    /** Restoration records deleted (their copies collected). */
+    /** Move records dropped: old ones no block shows at any more (a lost move, a move of removed blocks). */
     records: number;
-    /** Placement candidates dropped (runner-ups of an old, accepted winner). */
-    candidates: number;
     /** Claims naming a removed block, deleted from the blocks that hold them. */
     claims: number;
     /**
@@ -40,13 +41,21 @@ export type PurgeReport = {
      * contributors at the merge): deleted, their registry entries kept.
      */
     merged: number;
+    /** Release records the horizon covers (`hist.release.end`): deleted. */
+    released: number;
 };
+/**
+ * The ended histories a document holds (`hist.release.end`): per writer,
+ * the clock its latest live release record ended at (what it wrote below
+ * it is released).
+ */
+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: {
         model: PlacementModel;
         text: TextEngine;
-    }, horizon: Horizon) => PurgeReport;
+    }, horizon: Horizon | null) => PurgeReport;
 };
 export type PurgeBinding = ReturnType<typeof bindPurge>;