edytor 1.0.0-rc.3 → 1.0.0

package/dist/cloudflare/move.d.ts

@@ -29,6 +29,7 @@
  * `moveBlocksBetweenRooms(namespace, …)` runs steps 1–3 from the host Worker.
  */
 import type { JSONBlock } from '../utils/json.js';
+import { type Unit } from '../crdt/restore.js';
 /** Where imported blocks land in the destination: under `parent` at `index`. */
 export type MoveDestination = {
     parent: string | null;
@@ -105,23 +106,6 @@ export type MoveNamespace = {
 };
 /** The default grace period: late edits are forwarded this long after the commit. */
 export declare const DEFAULT_MOVE_GRACE_DAYS = 30;
-/** One display unit: a character (a code point) with its marks, or an inline atom. */
-type Unit = {
-    key: string;
-    text?: string;
-    marks?: Record<string, unknown>;
-    atom?: JSONBlock;
-};
-/** `content` one unit each, keyed for comparison. */
-export declare const unitsOf: (content?: JSONBlock["content"]) => Unit[];
-/** Units back to JSON content (adjacent text of equal marks joined). */
-export declare const contentOf: (units: readonly Unit[]) => NonNullable<JSONBlock["content"]>;
-/** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
-export declare const hunk: (x: readonly Unit[], y: readonly Unit[]) => {
-    p: number;
-    e: number;
-    mid: Unit[];
-};
 /**
  * Merge the source's change (`base` → `src`) into the destination's
  * (`base` → `dst`), each read as one stretch: disjoint stretches both
@@ -156,4 +140,3 @@ export declare const moveBlocksBetweenRooms: (namespace: MoveNamespace, move: {
  * cannot reach the destination itself. Returns how many batches went.
  */
 export declare const forwardLateEdits: (namespace: MoveNamespace, from: string) => Promise<number>;
-export {};

package/dist/cloudflare/move.js

@@ -1,54 +1,8 @@
 import { canonKey } from '../crdt/text/model.js';
+import { hunk } from '../crdt/restore.js';
 /** The default grace period: late edits are forwarded this long after the commit. */
 export const DEFAULT_MOVE_GRACE_DAYS = 30;
-/** `content` one unit each, keyed for comparison. */
-export const unitsOf = (content = []) => {
-    const out = [];
-    for (const item of content) {
-        if ('text' in item && typeof item.text === 'string') {
-            const marks = (item.marks ?? undefined);
-            const tag = canonKey(marks ?? {});
-            for (const ch of item.text)
-                out.push({ key: `${ch}|${tag}`, text: ch, marks });
-        }
-        else {
-            const atom = item;
-            out.push({
-                key: `@${atom.id ?? ''}|${atom.type}|${canonKey(atom.data ?? {})}`,
-                atom: atom
-            });
-        }
-    }
-    return out;
-};
-/** Units back to JSON content (adjacent text of equal marks joined). */
-export const contentOf = (units) => {
-    const out = [];
-    for (const u of units) {
-        if (u.atom !== undefined) {
-            out.push(u.atom);
-            continue;
-        }
-        const last = out[out.length - 1];
-        if (last?.text !== undefined && canonKey(last.marks ?? {}) === canonKey(u.marks ?? {}))
-            last.text += u.text;
-        else
-            out.push({ text: u.text, ...(u.marks === undefined ? {} : { marks: u.marks }) });
-    }
-    return out;
-};
-/** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
-export const hunk = (x, y) => {
-    let p = 0;
-    while (p < x.length && p < y.length && x[p].key === y[p].key)
-        p++;
-    let q = 0;
-    while (q < x.length - p &&
-        q < y.length - p &&
-        x[x.length - 1 - q].key === y[y.length - 1 - q].key)
-        q++;
-    return { p, e: x.length - q, mid: y.slice(p, y.length - q) };
-};
+// ── units and the three-way merge ─────────────────────────────────────
 /**
  * Merge the source's change (`base` → `src`) into the destination's
  * (`base` → `dst`), each read as one stretch: disjoint stretches both

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

@@ -18,14 +18,8 @@ export declare const allowance: <K>(allowances: {
     set(key: K, bucket: Bucket): unknown;
 }, key: K, perSecond: number, now?: number) => boolean;
 export declare class Admission {
+    #private;
     private readonly room;
-    /** Each socket's update allowance. */
-    private readonly allowances;
-    /**
-     * Each socket's chunked frame in flight, released when it ends or its
-     * socket closes (memory: a wake loses it, and the socket is faulted).
-     */
-    private readonly chunkReaders;
     constructor(room: RoomContext);
     /** Release `ws`'s chunk sequence in flight (it closed, or was closed). */
     forget(ws: WebSocket): void;
@@ -33,17 +27,6 @@ export declare class Admission {
     message(ws: WebSocket, message: string | ArrayBuffer): void;
     /** One frame: whole as it came, or reassembled from its chunks. */
     private onFrame;
-    /**
-     * One chunk of a frame too large to send whole (a provider's
-     * reconnect diff): buffered per socket into one buffer of the
-     * sequence's announced size, the whole frame handled once its sequence
-     * ends (`net.chunk.inbound`). A sequence announcing more than
-     * `maxInboundFrameBytes` is a frame quota refusal, before anything is
-     * buffered; its start is admitted by {@link admitChunks}. A part with no
-     * sequence started — the room woke between two chunks and lost the
-     * buffer — faults the socket (1011): its provider redials and resends.
-     */
-    private onChunk;
     /**
      * Admit a chunk sequence's start (`net.chunk.inbound`), before its
      * buffer is allocated: a read-only socket's is skipped, never buffered
@@ -57,57 +40,15 @@ export declare class Admission {
         sequences: number;
         bytes: number;
     };
-    /**
-     * A quota refused the socket's frame: it is not applied, and the
-     * socket is closed `4413` (`quota: <name>`), a refusal its provider
-     * reports (`onSyncRefused`) and does not redial. Never a dropped frame
-     * on a live socket: the sender's later frames would build on it and
-     * wait in the room's memory for good, unstored and unacknowledged; and
-     * a redial would resend it and meet the same quota.
-     */
-    private overQuota;
     /**
      * The update rate quota: a token bucket per socket, refilled at
      * `maxUpdatesPerSecond` up to ten seconds' worth. `false`: over it.
      * Presence messages draw from a bucket of their own (`RoomPresence`).
      */
     private allow;
-    /**
-     * The document quota: would `incoming` bytes take the document
-     * past `maxDocumentBytes`? Its measure is what its records hold and what
-     * the engine holds waiting; update records count until compaction
-     * collapses them, so it compacts first when they would.
-     */
-    private overDocument;
     private onSync;
     /** A client's Step2 or Update: admitted, applied, stored, relayed, validated, acknowledged. */
     private onUpdate;
-    /**
-     * A delete of items the room does not hold (a relayer's delete of an
-     * author's edit a restore lost) waits in the engine for them: it is
-     * stored as it arrives, so it survives eviction and compaction and
-     * applies when the author's edit returns. Except the entries the frame's
-     * own still-waiting rewrites replace (`stay`): those deletes wait with
-     * the rewrites in memory, as the rewrites may never integrate. A frame
-     * that released a pending forged stamp discarded every waiting delete
-     * (`applyRemote`): the stored ones go too. The deletes the frame applied
-     * from the waiting ones go back to its sender, whom the relay of the
-     * update skips; they are returned. The cap holds here too: deletes of
-     * the frame's own structs that wait for an origin (stored, or kept in
-     * memory with its rewrites) pass the check before applying; when the
-     * frame's new waiting deletes take the room past
-     * {@link MAX_WAITING_DELETES}, they are all dropped (refusal `waiting`,
-     * the sender's), unstored and unacknowledged. A replaced entry is
-     * deleted by its rewrite anyway, should that integrate.
-     */
-    private settleDeletes;
-    /**
-     * Of `deletes`, those the room stored — applied, or waiting in a
-     * `pending` record — and so acknowledges by id: never one it dropped
-     * (the waiting cap, a stripped rewrite's replaced entry) or keeps
-     * waiting in memory only.
-     */
-    private storedDeletes;
     /**
      * A frame that would write during a storage outage (`room.storage.outage`):
      * closed 1011 before it is applied, the live doc kept as stored. Its

package/dist/cloudflare/room/admission.js

@@ -59,18 +59,18 @@ class ChunksRefused extends Error {
 export class Admission {
     room;
     /** Each socket's update allowance. */
-    allowances = new WeakMap();
+    #allowances = new WeakMap();
     /**
      * Each socket's chunked frame in flight, released when it ends or its
      * socket closes (memory: a wake loses it, and the socket is faulted).
      */
-    chunkReaders = new Map();
+    #chunkReaders = new Map();
     constructor(room) {
         this.room = room;
     }
     /** Release `ws`'s chunk sequence in flight (it closed, or was closed). */
     forget(ws) {
-        this.chunkReaders.delete(ws);
+        this.#chunkReaders.delete(ws);
     }
     /** One message of a document socket (`AttachedDocument.webSocketMessage`). */
     message(ws, message) {
@@ -108,7 +108,7 @@ export class Admission {
         const limit = room.limits.maxInboundFrameBytes;
         // The frame quota: never decoded past it.
         if (bytes.length > limit) {
-            return this.overQuota(ws, attachment.user, 'frame', { bytes: bytes.length, limit });
+            return this.#overQuota(ws, attachment.user, 'frame', { bytes: bytes.length, limit });
         }
         const decoder = E.createDecoder(bytes);
         // 1 · Admission: the generation word, before anything is decoded.
@@ -118,7 +118,7 @@ export class Admission {
         try {
             const type = decode(() => E.readVarUint(decoder));
             if (type === E.messageChunk)
-                return this.onChunk(ws, attachment, doc, decoder);
+                return this.#onChunk(ws, attachment, doc, decoder);
             if (type === E.messageSync)
                 return this.onSync(ws, attachment, doc, decoder);
             if (type === E.messageAwareness) {
@@ -155,28 +155,28 @@ export class Admission {
      * sequence started — the room woke between two chunks and lost the
      * buffer — faults the socket (1011): its provider redials and resends.
      */
-    onChunk(ws, attachment, doc, decoder) {
+    #onChunk(ws, attachment, doc, decoder) {
         const room = this.room;
-        let read = this.chunkReaders.get(ws);
+        let read = this.#chunkReaders.get(ws);
         if (read === undefined) {
             read = E.createChunkReader(room.limits.maxInboundFrameBytes, (total) => this.admitChunks(ws, total));
-            this.chunkReaders.set(ws, read);
+            this.#chunkReaders.set(ws, read);
         }
         let whole;
         try {
             whole = read(decoder);
         }
         catch (error) {
-            this.chunkReaders.delete(ws);
+            this.#chunkReaders.delete(ws);
             if (error instanceof ChunkLimitError) {
-                return this.overQuota(ws, attachment.user, 'frame', {
+                return this.#overQuota(ws, attachment.user, 'frame', {
                     bytes: error.total,
                     limit: error.limit
                 });
             }
             if (error instanceof ChunksRefused) {
                 if (error.quota === 'rate') {
-                    return this.overQuota(ws, attachment.user, 'rate', error.detail);
+                    return this.#overQuota(ws, attachment.user, 'rate', error.detail);
                 }
                 // The room's buffer is full, not the sender at fault: it redials.
                 room.note({
@@ -215,7 +215,7 @@ export class Admission {
         if (!this.allow(ws))
             throw new ChunksRefused('rate', { perSecond: room.limits.maxUpdatesPerSecond });
         let buffered = 0;
-        for (const [other, read] of this.chunkReaders)
+        for (const [other, read] of this.#chunkReaders)
             if (other !== ws)
                 buffered += read.buffered;
         const limit = room.limits.maxBufferedBytes;
@@ -228,7 +228,7 @@ export class Admission {
     buffered() {
         let sequences = 0;
         let bytes = 0;
-        for (const read of this.chunkReaders.values()) {
+        for (const read of this.#chunkReaders.values()) {
             if (read.buffered === 0)
                 continue;
             sequences++;
@@ -244,11 +244,11 @@ export class Admission {
      * wait in the room's memory for good, unstored and unacknowledged; and
      * a redial would resend it and meet the same quota.
      */
-    overQuota(ws, user, quota, detail) {
+    #overQuota(ws, user, quota, detail) {
         const room = this.room;
         room.note({ reason: 'quota', detail: { user, quota, ...detail } });
         room.log({ edytor: 'quota', user, quota });
-        this.chunkReaders.delete(ws);
+        this.#chunkReaders.delete(ws);
         room.presence.depart(ws);
         room.close(ws, CLOSE.quota, `quota: ${quota}`);
     }
@@ -258,7 +258,7 @@ export class Admission {
      * Presence messages draw from a bucket of their own (`RoomPresence`).
      */
     allow(ws) {
-        return allowance(this.allowances, ws, this.room.limits.maxUpdatesPerSecond);
+        return allowance(this.#allowances, ws, this.room.limits.maxUpdatesPerSecond);
     }
     /**
      * The document quota: would `incoming` bytes take the document
@@ -266,7 +266,7 @@ export class Admission {
      * the engine holds waiting; update records count until compaction
      * collapses them, so it compacts first when they would.
      */
-    overDocument(incoming, freed) {
+    #overDocument(incoming, freed) {
         const room = this.room;
         const { storage } = room;
         const limit = room.limits.maxDocumentBytes;
@@ -295,7 +295,7 @@ export class Admission {
         const syncType = decode(() => E.readVarUint(decoder));
         // The rate quota counts every sync message, a Step1 too (it costs a Step2).
         if (!this.allow(ws)) {
-            return this.overQuota(ws, attachment.user, 'rate', {
+            return this.#overQuota(ws, attachment.user, 'rate', {
                 perSecond: room.limits.maxUpdatesPerSecond
             });
         }
@@ -313,11 +313,7 @@ export class Admission {
         if (syncType !== E.messageYjsSyncStep2 && syncType !== E.messageYjsUpdate) {
             return room.refuse(ws, { reason: 'malformed', detail: `sync type ${syncType}` });
         }
-        // A SyncStep2 is v2 on the wire: every path below reads v1.
-        const update = decode(() => {
-            const payload = E.readVarUint8Array(decoder);
-            return syncType === E.messageYjsSyncStep2 ? sync.step2Update(payload) : payload;
-        });
+        const update = decode(() => E.readVarUint8Array(decoder));
         const started = now();
         try {
             this.onUpdate(ws, attachment, doc, update);
@@ -345,8 +341,8 @@ export class Admission {
         }
         // The document quota, net of what the frame deletes.
         if (decoded.structs.some((struct) => !(struct instanceof Y.Skip)) &&
-            this.overDocument(update.length, freedBy(doc, decoded.ds))) {
-            return this.overQuota(ws, attachment.user, 'document', {
+            this.#overDocument(update.length, freedBy(doc, decoded.ds))) {
+            return this.#overQuota(ws, attachment.user, 'document', {
                 bytes: storage.documentBytes,
                 incoming: update.length,
                 limit: room.limits.maxDocumentBytes
@@ -445,7 +441,7 @@ export class Admission {
         const stay = doc.store.pendingStructs === null
             ? Y.createIdSet()
             : replacedEntries(doc, decoded.structs, ({ id }) => !stripped.has(id.client) && storedStruct(doc, id.client, id.clock) === null);
-        const released = room.handle(() => this.settleDeletes(ws, attachment.user, doc, waiting, stay, discarded !== undefined));
+        const released = room.handle(() => this.#settleDeletes(ws, attachment.user, doc, waiting, stay, discarded !== undefined));
         if (room.unstored !== null)
             return this.fault(ws, room.unstored);
         if (discarded)
@@ -464,7 +460,7 @@ export class Admission {
                 return this.fault(ws, room.unstored);
         }
         // A dropped delete is not acknowledged: its sender stays unsaved.
-        room.send(ws, savedFrame(doc, addIds(this.storedDeletes(doc, decoded.ds), released)));
+        room.send(ws, savedFrame(doc, addIds(this.#storedDeletes(doc, decoded.ds), released)));
         // Waiting writes the frame released are other sockets' (a relayer's
         // edit that built on an author's lost one): they are stored now, with
         // the deletes that waited with them.
@@ -491,7 +487,7 @@ export class Admission {
      * the sender's), unstored and unacknowledged. A replaced entry is
      * deleted by its rewrite anyway, should that integrate.
      */
-    settleDeletes(ws, user, doc, waiting, stay, discarded) {
+    #settleDeletes(ws, user, doc, waiting, stay, discarded) {
         const room = this.room;
         const { storage } = room;
         let now = pendingDeletes(doc);
@@ -535,7 +531,7 @@ export class Admission {
      * (the waiting cap, a stripped rewrite's replaced entry) or keeps
      * waiting in memory only.
      */
-    storedDeletes(doc, deletes) {
+    #storedDeletes(doc, deletes) {
         const unheld = Y.diffIdSet(deletes, heldDeletes(doc, deletes));
         return Y.diffIdSet(deletes, Y.diffIdSet(unheld, this.room.storage.storedWaiting));
     }

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

@@ -13,6 +13,7 @@ import { type RoomContext } from './context.js';
 /** The largest request body `routeDocumentComments` forwards, in bytes. */
 export declare const MAX_COMMENT_REQUEST_BYTES: number;
 export declare class RoomComments {
+    #private;
     private readonly room;
     private ready;
     /** Each verified user's HTTP request allowance (memory: a wake refills it). */
@@ -22,7 +23,6 @@ export declare class RoomComments {
     constructor(room: RoomContext);
     /** Comments are on unless the room's `comments` option is `false`. */
     get enabled(): boolean;
-    private ensure;
     /**
      * The comments' last sequence number (`0`: none yet): the one `meta`
      * keeps, and never below a stored thread's `rev` (a generation cutover
@@ -52,8 +52,6 @@ export declare class RoomComments {
      * anchor marks removed when it removed a thread; then `onComment`.
      */
     apply(request: CommentRequest, actor: CommentActor): Promise<CommentOutcome>;
-    /** A removed thread's anchor: its marks leave the document, as one room transaction. */
-    private removeAnchors;
     /** Send `change` to every socket that subscribed. */
     private broadcast;
     /**

package/dist/cloudflare/room/comments.js

@@ -50,7 +50,7 @@ export class RoomComments {
     get enabled() {
         return this.room.options.comments !== false;
     }
-    ensure() {
+    #ensure() {
         if (this.ready)
             return;
         const { sql, tables } = this.room;
@@ -134,7 +134,7 @@ export class RoomComments {
         if (!this.enabled)
             return { seq: 0, threads: [] };
         return noTimers(() => {
-            this.ensure();
+            this.#ensure();
             const { sql, tables } = this.room;
             const comments = new Map();
             for (const row of sql
@@ -186,7 +186,7 @@ export class RoomComments {
         if (!this.enabled)
             return { status: 'refused', reason: 'missing', message: 'no comments' };
         const outcome = noTimers(() => {
-            this.ensure();
+            this.#ensure();
             const { sql, tables } = room;
             const thread = validCommentId(request.thread) ? this.read(request.thread) : null;
             const threads = request.op === 'add'
@@ -212,7 +212,7 @@ export class RoomComments {
             this.store(decided.change);
             this.broadcast(decided.change);
             if (decided.change.type === 'removed')
-                this.removeAnchors(decided.change.thread.id);
+                this.#removeAnchors(decided.change.thread.id);
             room.log({
                 edytor: 'comment',
                 type: decided.change.type,
@@ -233,7 +233,7 @@ export class RoomComments {
         return outcome;
     }
     /** A removed thread's anchor: its marks leave the document, as one room transaction. */
-    removeAnchors(id) {
+    #removeAnchors(id) {
         const room = this.room;
         if (room.live === null || room.busy)
             return;
@@ -244,7 +244,7 @@ export class RoomComments {
             const mark = `${COMMENT_MARK}:${id}`;
             room.transact((facade) => {
                 for (const run of [...runs].reverse())
-                    facade.unsetMark(run.block, run.offset, run.length, mark);
+                    facade.formatRange(run.block, run.offset, run.length, { [mark]: null });
             });
         }
         catch (error) {