edytor 1.0.0-rc.2 → 1.0.0

package/dist/cloudflare/DocumentRoom.d.ts

@@ -52,11 +52,9 @@
  *   left out of the ack), the rest applied. Compaction reclaims the
  *   waiting deletes of client ids no user registered and no socket holds;
  *   `dropWaitingDeletes()` every one.
- * - storage format: the generation record says `storage: 'v2'` —
- *   snapshots in the v2 encoding, compressed in place after they are
- *   stored (`compressLater`), inflated at start (`inflate`); update and
- *   pending records stay v1. A container without `storage` (0.1.0-next.22)
- *   is all v1, and its next compaction rewrites it.
+ * - storage format: every record holds an update in the engine's one
+ *   encoding; a snapshot is compressed in place after it is stored
+ *   (`#compressLater`) and inflated at start (`inflate`).
  * - a Step2 serves the STORED state: the engine's pending structs (waiting
  *   for a dependency, never stored) are not served.
  * - a frame larger than `maxFrameBytes` (32 MiB) goes out as chunks the
@@ -128,6 +126,8 @@ export declare const DEFAULT_SAVE_AFTER = 2000;
  * about 100 MB at worst. Raise it for documents of long text.
  */
 export declare const DEFAULT_MAX_DOCUMENT_BYTES: number;
+/** The share of the document quota past which the room logs its size, by default. */
+export declare const DEFAULT_DOCUMENT_WARNING = 0.8;
 /**
  * The largest frame a socket may send, reassembled from chunks: room for a
  * whole document at the default quota (a client seeding an empty room).
@@ -211,6 +211,8 @@ export type DocumentRoomEnv = {
     EDYTOR_COMPACT_AFTER?: string | number;
     EDYTOR_SAVE_AFTER?: string | number;
     EDYTOR_MAX_DOCUMENT_BYTES?: string | number;
+    /** The share of the document quota past which the room logs its size (`documentWarning`). */
+    EDYTOR_DOCUMENT_WARNING?: string | number;
     EDYTOR_MAX_INBOUND_FRAME_BYTES?: string | number;
     EDYTOR_MAX_BUFFERED_BYTES?: string | number;
     EDYTOR_MAX_UPDATES_PER_SECOND?: string | number;
@@ -290,6 +292,8 @@ export type Timing = {
 export type RoomMetrics = {
     /** The document's size as the document quota measures it: its records, uncompressed. */
     documentBytes: number;
+    /** The document quota (`maxDocumentBytes`): writes past it are refused (`4413`). */
+    documentLimit: number;
     /** What its rows take in storage (a snapshot compressed). */
     storedBytes: number;
     /** Logical records stored (the generation record included), and their rows. */
@@ -366,6 +370,11 @@ export type RoomLogEntry = {
     edytor: 'quota';
     user: string;
     quota: string;
+} | {
+    edytor: 'size';
+    bytes: number;
+    limit: number;
+    share: number;
 } | {
     edytor: 'denied';
     user: string;
@@ -378,12 +387,6 @@ export type RoomLogEntry = {
     edytor: 'fault';
     reason: 'storage' | 'internal';
     detail: string;
-} | {
-    edytor: 'convert';
-    from: number;
-    to: number;
-    blocks: number;
-    bytes: number;
 } | {
     edytor: 'move';
     moveId: string;
@@ -400,12 +403,11 @@ export type RoomLogEntry = {
 };
 /** `pending`: deletes of items the room does not hold yet (they wait for them). */
 type RowKind = 'generation' | 'update' | 'snapshot' | 'pending';
-/** A stored record, reassembled: its kind, record number, bytes, and whether they are v2 (a v2 container's snapshot). */
+/** A stored record, reassembled: its kind, record number and bytes. */
 export type StoredRecord = {
     kind: RowKind;
     record: number;
     bytes: Uint8Array<ArrayBuffer>;
-    v2: boolean;
 };
 /** A block as `validate` reads it, before or after a frame. */
 export type ValidatedBlock = {
@@ -495,6 +497,12 @@ export type AttachRoomOptions = {
     tablePrefix?: string;
     /** Largest document, in stored bytes (default {@link DEFAULT_MAX_DOCUMENT_BYTES}). */
     maxDocumentBytes?: number;
+    /**
+     * The share of `maxDocumentBytes` past which the room logs the
+     * document's size (`size`, once per crossing), above 0 and at most 1
+     * (default {@link DEFAULT_DOCUMENT_WARNING}, 0.8).
+     */
+    documentWarning?: number;
     /** Largest frame a socket may send, reassembled (default {@link DEFAULT_MAX_INBOUND_FRAME_BYTES}). */
     maxInboundFrameBytes?: number;
     /**
@@ -588,6 +596,7 @@ export declare class AttachedDocument {
     readonly compactAfter: number;
     readonly saveAfter: number;
     readonly maxDocumentBytes: number;
+    readonly documentWarning: number;
     readonly maxInboundFrameBytes: number;
     readonly maxBufferedBytes: number;
     readonly maxUpdatesPerSecond: number;
@@ -608,10 +617,6 @@ export declare class AttachedDocument {
     } | {
         kind: 'restored';
         records: number;
-    } | {
-        kind: 'converted';
-        from: number;
-        records: number;
     };
     /** The room's parts and what they share (`room/context.ts`). */
     private readonly room;

package/dist/cloudflare/DocumentRoom.js

@@ -52,11 +52,9 @@
  *   left out of the ack), the rest applied. Compaction reclaims the
  *   waiting deletes of client ids no user registered and no socket holds;
  *   `dropWaitingDeletes()` every one.
- * - storage format: the generation record says `storage: 'v2'` —
- *   snapshots in the v2 encoding, compressed in place after they are
- *   stored (`compressLater`), inflated at start (`inflate`); update and
- *   pending records stay v1. A container without `storage` (0.1.0-next.22)
- *   is all v1, and its next compaction rewrites it.
+ * - storage format: every record holds an update in the engine's one
+ *   encoding; a snapshot is compressed in place after it is stored
+ *   (`#compressLater`) and inflated at start (`inflate`).
  * - a Step2 serves the STORED state: the engine's pending structs (waiting
  *   for a dependency, never stored) are not served.
  * - a frame larger than `maxFrameBytes` (32 MiB) goes out as chunks the
@@ -137,6 +135,8 @@ export const DEFAULT_SAVE_AFTER = 2000;
  * about 100 MB at worst. Raise it for documents of long text.
  */
 export const DEFAULT_MAX_DOCUMENT_BYTES = 2 * 1024 * 1024;
+/** The share of the document quota past which the room logs its size, by default. */
+export const DEFAULT_DOCUMENT_WARNING = 0.8;
 /**
  * The largest frame a socket may send, reassembled from chunks: room for a
  * whole document at the default quota (a client seeding an empty room).
@@ -200,6 +200,7 @@ export class AttachedDocument {
     compactAfter;
     saveAfter;
     maxDocumentBytes;
+    documentWarning;
     maxInboundFrameBytes;
     maxBufferedBytes;
     maxUpdatesPerSecond;
@@ -225,6 +226,8 @@ export class AttachedDocument {
         this.compactAfter = knob(options.compactAfter, DEFAULT_COMPACT_AFTER, 1e9);
         this.saveAfter = knob(options.saveAfter, DEFAULT_SAVE_AFTER, 1e9);
         this.maxDocumentBytes = knob(options.maxDocumentBytes, DEFAULT_MAX_DOCUMENT_BYTES, QUOTA_CEILING);
+        const warning = Number(options.documentWarning);
+        this.documentWarning = warning > 0 && warning <= 1 ? warning : DEFAULT_DOCUMENT_WARNING;
         this.maxInboundFrameBytes = knob(options.maxInboundFrameBytes, DEFAULT_MAX_INBOUND_FRAME_BYTES, QUOTA_CEILING);
         this.maxBufferedBytes = Math.max(this.maxInboundFrameBytes, knob(options.maxBufferedBytes, 2 * this.maxInboundFrameBytes, QUOTA_CEILING));
         this.maxUpdatesPerSecond = knob(options.maxUpdatesPerSecond, DEFAULT_MAX_UPDATES_PER_SECOND, QUOTA_CEILING);
@@ -492,6 +495,7 @@ export class AttachedDocument {
             const { counters } = room;
             return {
                 documentBytes: room.storage.documentBytes,
+                documentLimit: room.limits.maxDocumentBytes,
                 storedBytes: stored?.bytes ?? 0,
                 records: stored?.records ?? 0,
                 rows: stored?.rows ?? 0,
@@ -649,6 +653,7 @@ export class DocumentRoom extends DurableObject {
             compactAfter: Number(knobs.EDYTOR_COMPACT_AFTER),
             saveAfter: Number(knobs.EDYTOR_SAVE_AFTER),
             maxDocumentBytes: Number(knobs.EDYTOR_MAX_DOCUMENT_BYTES),
+            documentWarning: Number(knobs.EDYTOR_DOCUMENT_WARNING),
             maxInboundFrameBytes: Number(knobs.EDYTOR_MAX_INBOUND_FRAME_BYTES),
             maxBufferedBytes: Number(knobs.EDYTOR_MAX_BUFFERED_BYTES),
             maxUpdatesPerSecond: Number(knobs.EDYTOR_MAX_UPDATES_PER_SECOND),

package/dist/cloudflare/index.d.ts

@@ -4,7 +4,7 @@
  * `cloudflare:workers`); built on the Worker-safe CRDT entry. Documented in
  * the site's `server/` section (room, authorization, extending, protocol).
  */
-export { DocumentRoom, AttachedDocument, attachRoom, SOCKET_TAG, closedSocket, type AttachRoomOptions, type CommentOptions, DEFAULT_COMPACT_AFTER, DEFAULT_MAX_ROW_BYTES, DEFAULT_SAVE_AFTER, DEFAULT_MAX_DOCUMENT_BYTES, DEFAULT_MAX_INBOUND_FRAME_BYTES, DEFAULT_MAX_BUFFERED_BYTES, DEFAULT_MAX_UPDATES_PER_SECOND, DEFAULT_MAX_PRESENCE_BYTES, DEFAULT_MAX_PRESENCE_PER_SECOND, DEFAULT_MAX_PRESENCE_FANOUT, DEFAULT_MAX_COMMENT_BYTES, DEFAULT_MAX_COMMENT_REQUESTS_PER_SECOND, MAX_REFUSALS, MAX_WAITING_DELETES, ROOM_ORIGIN, RESTORE_ORIGIN, PURGE_ORIGIN, IDENTITY_HEADERS, PROBE_HEADER, noTimers, type Attachment, type DocumentRoomEnv, type LoadedDocument, type Refusal, type ReplicaOwner, type SavedDocument, type SocketIdentity, type StoredRecord, type FrameValidation, type ValidatedBlock, type RoomMetrics, type RoomLogEntry, type RestoreResult, type Timing } from './DocumentRoom.js';
+export { DocumentRoom, AttachedDocument, attachRoom, SOCKET_TAG, closedSocket, type AttachRoomOptions, type CommentOptions, DEFAULT_COMPACT_AFTER, DEFAULT_MAX_ROW_BYTES, DEFAULT_SAVE_AFTER, DEFAULT_MAX_DOCUMENT_BYTES, DEFAULT_DOCUMENT_WARNING, DEFAULT_MAX_INBOUND_FRAME_BYTES, DEFAULT_MAX_BUFFERED_BYTES, DEFAULT_MAX_UPDATES_PER_SECOND, DEFAULT_MAX_PRESENCE_BYTES, DEFAULT_MAX_PRESENCE_PER_SECOND, DEFAULT_MAX_PRESENCE_FANOUT, DEFAULT_MAX_COMMENT_BYTES, DEFAULT_MAX_COMMENT_REQUESTS_PER_SECOND, MAX_REFUSALS, MAX_WAITING_DELETES, ROOM_ORIGIN, RESTORE_ORIGIN, PURGE_ORIGIN, IDENTITY_HEADERS, PROBE_HEADER, noTimers, type Attachment, type DocumentRoomEnv, type LoadedDocument, type Refusal, type ReplicaOwner, type SavedDocument, type SocketIdentity, type StoredRecord, type FrameValidation, type ValidatedBlock, type RoomMetrics, type RoomLogEntry, type RestoreResult, type Timing } from './DocumentRoom.js';
 export { DEFAULT_RETENTION_DAYS, HISTORY_MAX_VALUE_BYTES, R2_HISTORY_MAX_VALUE_BYTES, ROOM_HISTORY_MAX_BYTES, ROOM_HISTORY_MAX_VALUE_BYTES, kvHistory, r2History, roomHistory, type HistoryEntry, type HistoryMetadata, type HistoryOptions, type HistoryRoomStorage, type HistoryStore, type HistoryStoreFactory, type HistoryStoreRecord, type KVLike, type R2BucketLike } from './history.js';
 export { type PurgeReport } from '../crdt/purge.js';
 export { COMMENT_ROW_BYTES, COMMENT_STATUS, MAX_COMMENT_LENGTH, MAX_COMMENTS_PER_THREAD, MAX_THREADS, commentAnchors, commentBytes, decideComment, type ThreadComment, type CommentActor, type CommentChange, type CommentOutcome, type CommentRefusal, type CommentRequest, type CommentRun, type CommentSnapshot, type CommentThread } from '../crdt/protocols/comments.js';

package/dist/cloudflare/index.js

@@ -4,7 +4,7 @@
  * `cloudflare:workers`); built on the Worker-safe CRDT entry. Documented in
  * the site's `server/` section (room, authorization, extending, protocol).
  */
-export { DocumentRoom, AttachedDocument, attachRoom, SOCKET_TAG, closedSocket, DEFAULT_COMPACT_AFTER, DEFAULT_MAX_ROW_BYTES, DEFAULT_SAVE_AFTER, DEFAULT_MAX_DOCUMENT_BYTES, DEFAULT_MAX_INBOUND_FRAME_BYTES, DEFAULT_MAX_BUFFERED_BYTES, DEFAULT_MAX_UPDATES_PER_SECOND, DEFAULT_MAX_PRESENCE_BYTES, DEFAULT_MAX_PRESENCE_PER_SECOND, DEFAULT_MAX_PRESENCE_FANOUT, DEFAULT_MAX_COMMENT_BYTES, DEFAULT_MAX_COMMENT_REQUESTS_PER_SECOND, MAX_REFUSALS, MAX_WAITING_DELETES, ROOM_ORIGIN, RESTORE_ORIGIN, PURGE_ORIGIN, IDENTITY_HEADERS, PROBE_HEADER, noTimers } from './DocumentRoom.js';
+export { DocumentRoom, AttachedDocument, attachRoom, SOCKET_TAG, closedSocket, DEFAULT_COMPACT_AFTER, DEFAULT_MAX_ROW_BYTES, DEFAULT_SAVE_AFTER, DEFAULT_MAX_DOCUMENT_BYTES, DEFAULT_DOCUMENT_WARNING, DEFAULT_MAX_INBOUND_FRAME_BYTES, DEFAULT_MAX_BUFFERED_BYTES, DEFAULT_MAX_UPDATES_PER_SECOND, DEFAULT_MAX_PRESENCE_BYTES, DEFAULT_MAX_PRESENCE_PER_SECOND, DEFAULT_MAX_PRESENCE_FANOUT, DEFAULT_MAX_COMMENT_BYTES, DEFAULT_MAX_COMMENT_REQUESTS_PER_SECOND, MAX_REFUSALS, MAX_WAITING_DELETES, ROOM_ORIGIN, RESTORE_ORIGIN, PURGE_ORIGIN, IDENTITY_HEADERS, PROBE_HEADER, noTimers } from './DocumentRoom.js';
 export { DEFAULT_RETENTION_DAYS, HISTORY_MAX_VALUE_BYTES, R2_HISTORY_MAX_VALUE_BYTES, ROOM_HISTORY_MAX_BYTES, ROOM_HISTORY_MAX_VALUE_BYTES, kvHistory, r2History, roomHistory } from './history.js';
 export {} from '../crdt/purge.js';
 export { COMMENT_ROW_BYTES, COMMENT_STATUS, MAX_COMMENT_LENGTH, MAX_COMMENTS_PER_THREAD, MAX_THREADS, commentAnchors, commentBytes, decideComment } from '../crdt/protocols/comments.js';

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) {