edytor 6.0.0 → 7.0.0

package/dist/cloudflare/room/forged.d.ts

@@ -9,7 +9,7 @@ export declare const isId: (value: unknown) => value is Id;
  * The clients of a frame (but `skip`) that write a per-writer block mark
  * of another writer: a struct whose key is `del.<n>` or `wd.<n>` on a
  * block node, from a client other than `n`. Only `n` writes its mark.
- * A struct in the purge horizon's root forges the room's.
+ * A struct in the purge horizon's root, or the epoch's, forges the room's.
  */
 export declare const forgedWriters: (doc: YDoc, structs: Struct[], skip: Set<number>) => Set<number>;
 /**

package/dist/cloudflare/room/forged.js

@@ -1,13 +1,13 @@
 /**
  * Forged writes: what a frame writes or deletes that its sender may not —
  * another writer's per-writer block mark (`room.marks.writer`), the purge
- * horizon (the room's alone), another replica's binding or another user's
+ * horizon and the epoch (the room's alone), another replica's binding or another user's
  * profile in the attribution root (`room.attribution.trust`). Pure reads of
  * the room document and the frame; `Admission` strips or drops what they
  * find.
  */
 import { Y } from '../../crdt/engine.js';
-import { ATTRIBUTION_ROOT, DEL_PREFIX, HORIZON_ROOT, REGISTRY_KEY, SUGGEST_ROOT, WITHDRAW_PREFIX } from '../../crdt/schema.js';
+import { ATTRIBUTION_ROOT, DEL_PREFIX, EPOCH_ROOT, HORIZON_ROOT, REGISTRY_KEY, SUGGEST_ROOT, WITHDRAW_PREFIX } from '../../crdt/schema.js';
 import { heldClock, runsOf, storedStruct, structAt } from './updates.js';
 // ── Per-writer marks ──────────────────────────────────────────
 /** The writer `n` of a per-writer block mark key (`del.<n>`, `wd.<n>`), or `null`. */
@@ -63,14 +63,16 @@ const isBlockNode = (doc, frame, parent) => {
     const item = parent?._item;
     return item?.parent === registry && registry !== undefined;
 };
-/** Is `parent` (a {@link Place}'s) the purge horizon's root, which only the room writes? */
-const isHorizon = (doc, parent) => parent === HORIZON_ROOT ||
-    (parent != null && parent === doc.share.get(HORIZON_ROOT));
+/**
+ * Is `parent` (a {@link Place}'s) a root only the room writes: the purge
+ * horizon's, or the epoch's (`room.reseed.protocol`)?
+ */
+const isRoomRoot = (doc, parent) => [HORIZON_ROOT, EPOCH_ROOT].some((root) => parent === root || (parent != null && parent === doc.share.get(root)));
 /**
  * The clients of a frame (but `skip`) that write a per-writer block mark
  * of another writer: a struct whose key is `del.<n>` or `wd.<n>` on a
  * block node, from a client other than `n`. Only `n` writes its mark.
- * A struct in the purge horizon's root forges the room's.
+ * A struct in the purge horizon's root, or the epoch's, forges the room's.
  */
 export const forgedWriters = (doc, structs, skip) => {
     const frame = runsOf(structs);
@@ -83,7 +85,7 @@ export const forgedWriters = (doc, structs, skip) => {
             continue;
         const place = placeOf(doc, frame, struct.id);
         const writer = markWriter(place?.key);
-        if ((place !== null && isHorizon(doc, place.parent)) ||
+        if ((place !== null && isRoomRoot(doc, place.parent)) ||
             (writer !== null && writer !== client && isBlockNode(doc, frame, place.parent))) {
             forged.add(client);
         }
@@ -113,8 +115,8 @@ export const forgedDeletes = (doc, ds, mayDelete) => {
                     break;
                 if (!(struct instanceof Y.Item) || struct.deleted)
                     continue;
-                // The purge horizon is the room's alone.
-                if (!isHorizon(doc, struct.parent)) {
+                // The purge horizon and the epoch are the room's alone.
+                if (!isRoomRoot(doc, struct.parent)) {
                     const writer = markWriter(struct.parentSub);
                     if (writer === null || mayDelete(writer))
                         continue;

package/dist/cloudflare/room/frames.d.ts

@@ -29,6 +29,8 @@ export declare const readOnlyFrame: () => Uint8Array;
 export declare const readOnlyDenialFrame: () => Uint8Array;
 /** The denial of what a suggest-only socket may not write (stripped): it stays, and still syncs. */
 export declare const suggestOnlyDenialFrame: () => Uint8Array;
+/** The room's epoch, to a socket that dialed an older one (`room.reseed.protocol`). */
+export declare const epochFrame: (epoch: number) => Uint8Array;
 /** The socket's access, at the join and at a change in place (`write`, `suggest`, `comment`, `read`). */
 export declare const accessFrame: (access: string) => Uint8Array;
 /** A Step2 of what the room STORED: the engine's pending store (never stored) is left out. */

package/dist/cloudflare/room/frames.js

@@ -51,6 +51,8 @@ export const readOnlyFrame = () => E.frame(E.messageAuth, (e) => E.writeReadOnly
 export const readOnlyDenialFrame = () => E.frame(E.messageAuth, (e) => E.writePermissionDenied(e, READ_ONLY_DENIAL));
 /** The denial of what a suggest-only socket may not write (stripped): it stays, and still syncs. */
 export const suggestOnlyDenialFrame = () => E.frame(E.messageAuth, (e) => E.writePermissionDenied(e, SUGGEST_ONLY_DENIAL));
+/** The room's epoch, to a socket that dialed an older one (`room.reseed.protocol`). */
+export const epochFrame = (epoch) => E.frame(E.messageAuth, (e) => E.writeEpoch(e, epoch));
 /** The socket's access, at the join and at a change in place (`write`, `suggest`, `comment`, `read`). */
 export const accessFrame = (access) => E.frame(E.messageAuth, (e) => E.writeAccess(e, access));
 /** A Step2 of what the room STORED: the engine's pending store (never stored) is left out. */

package/dist/cloudflare/room/presence.js

@@ -7,7 +7,6 @@
  * the socket goes.
  */
 import { semanticsMismatch } from '../../crdt/semantics.js';
-import { SOCKET_TAG } from './shared.js';
 import { allowance } from './admission.js';
 import { encodeJSON } from './context.js';
 import { encodePresenceEntry, presenceFrame, presenceFrameOf } from './frames.js';
@@ -142,9 +141,7 @@ export class RoomPresence {
      * replica, and {@link drain} sends each recipient's in one frame.
      */
     fanOut(entries) {
-        const sockets = this.room.ctx
-            .getWebSockets(SOCKET_TAG)
-            .filter((socket) => socket.readyState === WebSocket.OPEN);
+        const sockets = this.room.sockets();
         if (sockets.length === 0)
             return;
         if (this.waiting.size === 0 && this.take(sockets.length)) {

package/dist/cloudflare/room/reseed.d.ts

@@ -0,0 +1,93 @@
+import * as E from '../../crdt/protocol.js';
+import type { YDoc } from '../../crdt/index.js';
+import type { Attachment, SocketIdentity } from '../DocumentRoom.js';
+import type { Decoded } from './context.js';
+import { type RoomContext } from './context.js';
+/** An epoch a dial names (`?epoch=`; `new`: a document that holds nothing yet), or `null`. */
+export declare const parseEpoch: (raw: string | null) => number | "new" | null;
+export declare class RoomReseed {
+    #private;
+    private readonly room;
+    constructor(room: RoomContext);
+    /** The re-seed's settings (`null`: off). */
+    get config(): {
+        at: number;
+        idleMs: number;
+        gain: number;
+        force: number;
+        graceDays: number;
+    } | null;
+    /** The room's epoch: what its document says (`epoch.n`, which only the room writes), 0 before a re-seed. */
+    get epoch(): number;
+    /**
+     * A change was stored at `at` (`room.reseed.timing`): past the
+     * threshold the re-seed is due once nobody writes for `idleMs` (each
+     * change pushes it back), past `force` at once.
+     */
+    noteChange(at: number): void;
+    /**
+     * The `reseed` task: the cuts past their grace go (`room.reseed.grace`),
+     * then it re-seeds when still due (past the threshold and the floor); a
+     * re-seed that failed is due again at the first change a minute later or
+     * more. It is due again when the oldest cut left expires.
+     */
+    task(): void;
+    /**
+     * Re-seed now (`room.reseed.cut`): the new epoch replaces the rows, in
+     * one storage transaction with its cut; the replica registry, the
+     * purge's epochs and the last restore's step go (they name the old
+     * identities); the live document is rebuilt from the rows and every
+     * socket closed `4410`. `idle` (the task, once nobody wrote) waits while
+     * a suggestion is pending (an idle period later); `full` (the task, past
+     * `force` of the quota) drops them; both do nothing when the new epoch
+     * would give back less than `gain` (and wait for the document to grow by
+     * a quarter of `at` before trying again). `manual` (`reseed()`) runs
+     * whatever it gives back and drops them. Answers the new epoch, or `null`.
+     */
+    run(mode: 'idle' | 'full' | 'manual'): number | null;
+    /**
+     * The door (`RoomAccess.accept`, `room.reseed.protocol`): a dial of
+     * epoch `asked` is current, stale (an older epoch whose cuts are kept),
+     * or closed: none, in a room that re-seeded, `1008` (a client that
+     * predates the re-seed); any other epoch the room cannot rebase (past
+     * the cuts kept, or later than its own: the room lost it), `4410`, so
+     * the client drops its copy and loads the room's.
+     */
+    door(asked: number | 'new' | null): 'current' | 'stale' | {
+        code: number;
+        reason: string;
+    };
+    /**
+     * Whether `decoded`, from a socket of the current epoch, holds an older
+     * epoch's content (`room.reseed.protocol`): a struct of a client the
+     * cuts kept name, which the document holds nothing of (a tab took it
+     * from another tab of the old epoch). Its socket is closed `4410`.
+     */
+    holdsOld(decoded: Decoded, doc: YDoc): boolean;
+    /** The largest frame a socket of an older epoch may send: its whole old document. */
+    get staleFrameBytes(): number;
+    /**
+     * A stale socket joined: one that may write is told the room's epoch
+     * (its provider then hands over its old document); any other has no
+     * edit to merge and is closed `4410`. Past its user's rebase rate it is
+     * closed `1011` before it uploads anything: its provider dials again
+     * later.
+     */
+    join(ws: WebSocket, identity: SocketIdentity): void;
+    /**
+     * A stale socket's message: its old document (`messageRebase`) is
+     * rebased onto a copy of the current one, and what that wrote is
+     * admitted as an update of its user, from a client id of its own (the
+     * admission's quotas, access, validation and attribution, as any
+     * update); then it is closed `4410`. The merged state is kept per user
+     * and cut (`merged:<user>`), so another tab's upload merges nothing
+     * twice and another user's cannot claim it. A hand-over that cannot be
+     * read or rebased is dropped, its socket closed `4410` all the same (its
+     * client loads the room's document); past the rebase rate (one per user
+     * every ten seconds), `1011`, and the provider hands over again later.
+     * Anything else a stale socket sends is dropped.
+     */
+    onStale(ws: WebSocket, attachment: Attachment, type: number, decoder: E.Decoder): void;
+    /** Drop the cuts older than the grace, with what their rebases merged (`room.reseed.grace`). */
+    prune(at: number): void;
+}