edytor 1.0.0-rc.3 → 1.0.0

package/dist/cloudflare/room/history.js

@@ -5,7 +5,6 @@
  * and undoing that restore. The stores themselves are `../history.ts`.
  */
 import { Y } from '../../crdt/engine.js';
-import * as E from '../../crdt/protocol.js';
 import { gunzip, packed } from '../../crdt/storage.js';
 import { asEngineDoc, collectable, collectNow, collects, engineOps, stepsOf } from '../../crdt/structs.js';
 import { PURGE_ORIGIN, RESTORE_ORIGIN, noTimers } from './shared.js';
@@ -21,9 +20,9 @@ export class RoomHistory {
     /** Who the room writes for while a restore or its undo runs (the slot's editor). */
     writer = null;
     /** The last restore's step (`room.history.undo`), read from the `restore` table at load. */
-    restoreStep = null;
+    #restoreStep = null;
     /** The history recording restores (`RESTORE_ORIGIN`), on the live facade. */
-    restoreManager = null;
+    #restoreManager = null;
     /** The version writes in flight (`historyWritten()`). */
     writing = Promise.resolve();
     _config;
@@ -94,24 +93,24 @@ export class RoomHistory {
         const room = this.room;
         if ((room.scheduler.due('history') ?? Infinity) > room.clock())
             return;
-        const captured = this.captureSlot();
+        const captured = this.#captureSlot();
         if (captured === null)
             return;
-        const job = this.putSlot(captured);
+        const job = this.#putSlot(captured);
         this.writing = Promise.all([this.writing, job]);
         room.ctx.waitUntil?.(job);
     }
     /** Close the open slot: capture it now, write it (the alarm, a start past its end). */
     async closeSlot() {
-        const captured = this.captureSlot();
+        const captured = this.#captureSlot();
         if (captured !== null)
-            await this.putSlot(captured);
+            await this.#putSlot(captured);
     }
     /**
      * The open slot's version, read now (synchronous: nothing writes
      * between the read and the slot's close), and the slot closed.
      */
-    captureSlot() {
+    #captureSlot() {
         const room = this.room;
         const { scheduler } = room;
         const end = scheduler.due('history');
@@ -125,7 +124,7 @@ export class RoomHistory {
         if (room.live === null) {
             // No document to read (its rows unreadable, or refused): that slot is skipped.
             scheduler.unschedule('history');
-            this.skipVersion({
+            this.#skipVersion({
                 key: historyKey(this.room.roomId, slotAt(end - 1, config.timeZone)),
                 error: 'room unavailable'
             });
@@ -144,20 +143,20 @@ export class RoomHistory {
             this.slotEditors.clear();
             scheduler.unschedule('history');
             if (key === null) {
-                this.skipVersion({ room: this.room.roomId, reason: 'key longer than 512 bytes' });
+                this.#skipVersion({ room: this.room.roomId, reason: 'key longer than 512 bytes' });
                 return null;
             }
             return { key, raw, blocks, editors, at: room.clock() };
         });
     }
     /** Write a captured version (`room.history.value`); a failure is noted `history` and the slot skipped. */
-    async putSlot(version) {
+    async #putSlot(version) {
         const room = this.room;
         const config = this.config;
         try {
             const bytes = await packed(version.raw);
             if (bytes.length > config.maxValueBytes) {
-                return this.skipVersion({
+                return this.#skipVersion({
                     key: version.key,
                     bytes: bytes.length,
                     limit: config.maxValueBytes
@@ -184,15 +183,15 @@ export class RoomHistory {
             });
         }
         catch (error) {
-            this.skipVersion({ key: version.key, error: String(error) });
+            this.#skipVersion({ key: version.key, error: String(error) });
         }
     }
-    skipVersion(detail) {
+    #skipVersion(detail) {
         this.room.counters.history.skipped++;
         this.room.note({ reason: 'history', detail });
     }
     /** The history settings, or a throw: the room keeps no history. */
-    requireHistory() {
+    #requireHistory() {
         const config = this.config;
         if (config === null)
             throw new Error('this room keeps no history (the `history` option)');
@@ -205,10 +204,10 @@ export class RoomHistory {
     // ── Versions ─────────────────────────────────────────────────────────
     /** The room's versions, newest first (`AttachedDocument.listHistory`). */
     async list() {
-        const config = this.requireHistory();
+        const config = this.#requireHistory();
         const now = this.room.clock();
         const out = [];
-        for await (const { key, expiresAt, metadata } of this.storedVersions(config.store)) {
+        for await (const { key, expiresAt, metadata } of this.#storedVersions(config.store)) {
             // Past its expiry it is gone, whether or not the store deleted it yet.
             if (expiresAt !== null && expiresAt <= now)
                 continue;
@@ -219,7 +218,7 @@ export class RoomHistory {
         return out.sort((a, b) => (a.key < b.key ? 1 : a.key > b.key ? -1 : 0));
     }
     /** Every version key the store holds under this room's prefix, page by page. */
-    async *storedVersions(store) {
+    async *#storedVersions(store) {
         const prefix = historyPrefix(this.room.roomId);
         let cursor;
         do {
@@ -244,7 +243,7 @@ export class RoomHistory {
         let next = Infinity;
         try {
             const expired = [];
-            for await (const { key, expiresAt } of this.storedVersions(config.store)) {
+            for await (const { key, expiresAt } of this.#storedVersions(config.store)) {
                 if (expiresAt === null || parseHistoryKey(this.room.roomId, key) === null)
                     continue;
                 if (expiresAt <= now)
@@ -267,7 +266,7 @@ export class RoomHistory {
     /** Version `key` as JSON (`AttachedDocument.readHistory`). */
     async read(key) {
         const room = this.room;
-        const config = this.requireHistory();
+        const config = this.#requireHistory();
         if (parseHistoryKey(this.room.roomId, key) === null)
             return null;
         const found = await config.store.get(key);
@@ -275,17 +274,7 @@ export class RoomHistory {
             return null;
         const bytes = await gunzip(found.value);
         return noTimers(() => {
-            let doc;
-            try {
-                doc = admit([{ v2: bytes }], `room ${room.ctx.id} version ${key}`, () => null);
-            }
-            catch (error) {
-                // A version written by generation 4 reads through its JSON (`room.generation.convert`).
-                const problem = error.problem;
-                if (problem?.kind !== 'unsupported' || problem.version !== E.PREVIOUS_SCHEMA)
-                    throw error;
-                return crdt.generations.previousJSON([{ v2: bytes }], (d) => room.facadeOf(d));
-            }
+            const doc = admit(bytes, `room ${room.ctx.id} version ${key}`, () => null);
             const facade = room.facadeOf(doc);
             try {
                 return facade.toJSON();
@@ -299,7 +288,7 @@ export class RoomHistory {
     // ── Restores (`room.history.restore`, `room.history.undo`) ───────────
     /** The last restore's deleted content, kept for its undo (`prepareRoomDoc`). */
     get restoreKeep() {
-        return this.restoreStep?.deletes ?? null;
+        return this.#restoreStep?.deletes ?? null;
     }
     /** Restore version `key` as a forward edit (`AttachedDocument.restoreHistory`). */
     async restore(key, options = {}) {
@@ -315,9 +304,9 @@ export class RoomHistory {
             room.storage.heal();
             const doc = room.requireDoc();
             this.closeSlotIfPast();
-            const history = this.restoreHistoryOf();
+            const history = this.#restoreHistoryOf();
             // One level: the previous restore's step goes.
-            this.dropRestore();
+            this.#dropRestore();
             this.writer = options.user ?? null;
             let report;
             room.transacting = true;
@@ -346,7 +335,7 @@ export class RoomHistory {
                 deletes: step.deletes
             };
             room.sql.exec(`INSERT OR REPLACE INTO ${room.tables.restore} (id, key, user, at, inserts, deletes) VALUES (0, ?, ?, ?, ?, ?)`, kept.key, kept.user, kept.at, deletesUpdate(kept.inserts), deletesUpdate(kept.deletes));
-            this.restoreStep = kept;
+            this.#restoreStep = kept;
             room.log({ edytor: 'restore', key, user: kept.user, undo: false });
             room.storage.compactIfDue();
             return { status: 'applied', key, ...report };
@@ -362,10 +351,10 @@ export class RoomHistory {
             }
             room.storage.heal();
             room.requireDoc();
-            const step = this.restoreStep;
+            const step = this.#restoreStep;
             if (step === null)
                 return { status: 'noop' };
-            const history = this.restoreHistoryOf();
+            const history = this.#restoreHistoryOf();
             // A woken room rebuilds the step from its table.
             if (history.undoStack.length === 0) {
                 stepsOf(history.undoStack).push({
@@ -390,15 +379,15 @@ export class RoomHistory {
                 room.storage.heal();
                 throw error;
             }
-            this.dropRestore();
+            this.#dropRestore();
             room.log({ edytor: 'restore', key: step.key, user: options.user ?? null, undo: true });
             room.storage.compactIfDue();
             return { status: undone ? 'applied' : 'noop' };
         });
     }
     /** The history recording restores, on the live facade (`RESTORE_ORIGIN` only, one step each). */
-    restoreHistoryOf() {
-        return (this.restoreManager ??= this.room.facade.createUndoManager({
+    #restoreHistoryOf() {
+        return (this.#restoreManager ??= this.room.facade.createUndoManager({
             captureTimeout: 0,
             trackedOrigins: new Set([RESTORE_ORIGIN])
         }));
@@ -408,7 +397,7 @@ export class RoomHistory {
         const row = this.room.sql
             .exec(`SELECT key, user, at, inserts, deletes FROM ${this.room.tables.restore} WHERE id = 0`)
             .toArray()[0];
-        this.restoreStep =
+        this.#restoreStep =
             row === undefined
                 ? null
                 : {
@@ -419,38 +408,34 @@ export class RoomHistory {
                     deletes: Y.decodeUpdate(new Uint8Array(row.deletes)).ds
                 };
     }
-    /** Forget the last restore's step (its table was emptied: a conversion). */
-    clearRestore() {
-        this.restoreStep = null;
-    }
     /** Forget the restore's step and the open slot's editors (a reset dropped their tables). */
     forget() {
-        this.restoreStep = null;
+        this.#restoreStep = null;
         this.slotEditors.clear();
     }
     /** The live document was replaced: the restore history recorded the old one. */
     detach() {
-        this.restoreManager = null;
+        this.#restoreManager = null;
     }
     /** A restore past the purge horizon `at` can no longer be undone. */
     expireRestore(at) {
-        if (this.restoreStep !== null && this.restoreStep.at <= at)
-            this.dropRestore();
+        if (this.#restoreStep !== null && this.#restoreStep.at <= at)
+            this.#dropRestore();
     }
     /**
      * Forget the last restore's step: its table row goes, then what it kept
      * is released and collected (the next compaction stores it collected).
      */
-    dropRestore() {
+    #dropRestore() {
         const room = this.room;
-        const step = this.restoreStep;
+        const step = this.#restoreStep;
         if (step === null)
             return;
-        this.restoreStep = null;
+        this.#restoreStep = null;
         room.sql.exec(`DELETE FROM ${room.tables.restore}`);
-        const history = this.restoreManager;
+        const history = this.#restoreManager;
         if (history !== null)
-            room.facade.releaseHistory(history);
+            history.clear();
         const doc = room.live;
         if (doc === null)
             return;

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

@@ -1,15 +1,13 @@
 import { type CommitResult, type ExportedBlocks, type ImportReceipt, type ImportRequest, type LateEditBatch } from '../move.js';
 import { type RoomContext } from './context.js';
 export declare class RoomMoves {
+    #private;
     private readonly room;
     /** The blocks moved out and watched for late edits, by id → their move (`null`: not read yet). */
     private watched;
     constructor(room: RoomContext);
     /** Forget the watched blocks (a reset dropped the moves table). */
     forget(): void;
-    private ensureMoves;
-    /** One move's row. */
-    private moveRow;
     /** Days a moved-out block is watched for late edits: the purge horizon, else {@link DEFAULT_MOVE_GRACE_DAYS}. */
     private get graceMs();
     /** Export blocks `ids` for a move (`AttachedDocument.exportBlocks`). */
@@ -35,12 +33,6 @@ export declare class RoomMoves {
         applied: number;
         skipped: string[];
     };
-    /** One block's late edit, merged into what it holds (inside a room transaction). */
-    private mergeLateEdit;
-    /** The registry entries carrying a `del.<marker>` mark written between clocks `c0` and `c1`. */
-    private markedBetween;
-    /** The moved-out blocks watched for late edits (`room.move.late`), by id → their move. */
-    private watchedBlocks;
     /** A transaction that changed a watched block marks its move dirty (inside the `update` emit: no doc write). */
     noteLateEdits(tr: {
         changed?: Map<unknown, Set<string | null>>;
@@ -53,8 +45,4 @@ export declare class RoomMoves {
      * grace period. A forward that fails runs again a minute later.
      */
     forwardMoves(): Promise<void>;
-    /** The document's blocks as they show without the deletes of `moves`' commits: a copy, read once. */
-    private withoutMoveDeletes;
-    /** One dirty move's changes since its last batch, as a new batch of late edits (or a report). */
-    private collectLateEdits;
 }

package/dist/cloudflare/room/moves.js

@@ -7,9 +7,10 @@
 import { Y } from '../../crdt/engine.js';
 import { DEL_PREFIX, REGISTRY_KEY } from '../../crdt/schema.js';
 import { asEngineDoc, attrItems } from '../../crdt/structs.js';
-import { toBlockSpec } from '../../utils/json.js';
+import { jsonContentToItems, toBlockSpec } from '../../utils/json.js';
+import { rewriteContent, unitsOf } from '../../crdt/restore.js';
 import { noTimers } from './shared.js';
-import { DEFAULT_MOVE_GRACE_DAYS, contentOf, flattenMoved, hunk, mergeData, subtreesOf, threeWay, unitsOf } from '../move.js';
+import { DEFAULT_MOVE_GRACE_DAYS, flattenMoved, mergeData, subtreesOf, threeWay } from '../move.js';
 import { DAY, crdt } from './context.js';
 /** A forward of late edits that failed runs again this much later (`room.move.late`). */
 const FORWARD_RETRY = 60_000;
@@ -24,7 +25,7 @@ export class RoomMoves {
     forget() {
         this.watched = null;
     }
-    ensureMoves() {
+    #ensureMoves() {
         const { sql, tables } = this.room;
         sql.exec(`CREATE TABLE IF NOT EXISTS ${tables.moves} (
 				id TEXT PRIMARY KEY,
@@ -45,8 +46,8 @@ export class RoomMoves {
         sql.exec(`CREATE TABLE IF NOT EXISTS ${tables.late} (move TEXT NOT NULL, seq INTEGER NOT NULL, edits TEXT NOT NULL, PRIMARY KEY (move, seq))`);
     }
     /** One move's row. */
-    moveRow(id, role) {
-        this.ensureMoves();
+    #moveRow(id, role) {
+        this.#ensureMoves();
         return this.room.sql
             .exec(`SELECT * FROM ${this.room.tables.moves} WHERE id = ? AND role = ?`, id, role)
             .toArray()[0];
@@ -65,7 +66,7 @@ export class RoomMoves {
             if (blocks.length === 0)
                 throw new Error('exportBlocks: none of these blocks shows');
             const moveId = crypto.randomUUID();
-            this.ensureMoves();
+            this.#ensureMoves();
             room.sql.exec(`INSERT INTO ${room.tables.moves} (id, role, state, roots, sent, at) VALUES (?, 'out', 'exported', ?, ?, ?)`, moveId, JSON.stringify(blocks.map((b) => b.id)), JSON.stringify(blocks), room.clock());
             return { moveId, blocks };
         });
@@ -74,7 +75,7 @@ export class RoomMoves {
     importBlocks(request) {
         const room = this.room;
         return noTimers(() => {
-            const known = this.moveRow(request.moveId, 'in');
+            const known = this.#moveRow(request.moveId, 'in');
             if (known !== undefined)
                 return { moveId: request.moveId, status: 'applied', ids: JSON.parse(known.map) };
             const facade = room.facade;
@@ -118,7 +119,7 @@ export class RoomMoves {
     commitMove(moveId, receipt) {
         const room = this.room;
         return noTimers(() => {
-            const row = this.moveRow(moveId, 'out');
+            const row = this.#moveRow(moveId, 'out');
             if (row === undefined)
                 return { moveId, status: 'refused', reason: 'unknown move' };
             if (row.state === 'moved' || row.state === 'done')
@@ -135,7 +136,7 @@ export class RoomMoves {
                         f.apply(f.prepare.deleteBlock(id, { keepChildren: false }));
             });
             const c1 = doc.store.getClock(marker);
-            const watched = this.markedBetween(room.requireDoc(), marker, c0, c1);
+            const watched = this.#markedBetween(room.requireDoc(), marker, c0, c1);
             room.sql.exec(`UPDATE ${room.tables.moves} SET state = 'moved', peer = ?, map = ?, marker = ?, c0 = ?, c1 = ?, watched = ?, at = ?, dirty = 1 WHERE id = ? AND role = 'out'`, receipt.to, JSON.stringify(receipt.ids), marker, c0, c1, JSON.stringify(watched), room.clock(), moveId);
             this.watched = null;
             room.scheduler.schedule('forward', room.clock(), 'earlier');
@@ -145,8 +146,8 @@ export class RoomMoves {
     }
     /** Drop an export that was not committed (`AttachedDocument.abortMove`). */
     abortMove(moveId) {
-        this.ensureMoves();
-        const row = this.moveRow(moveId, 'out');
+        this.#ensureMoves();
+        const row = this.#moveRow(moveId, 'out');
         if (row?.state !== 'exported')
             return { moveId, status: 'noop' };
         this.room.sql.exec(`UPDATE ${this.room.tables.moves} SET state = 'aborted', sent = '[]' WHERE id = ? AND role = 'out'`, moveId);
@@ -155,7 +156,7 @@ export class RoomMoves {
     /** The late edits waiting to reach their destination, oldest first. */
     lateEdits() {
         const { sql, tables } = this.room;
-        this.ensureMoves();
+        this.#ensureMoves();
         return sql
             .exec(`SELECT l.move AS move, l.seq AS seq, l.edits AS edits, m.peer AS peer FROM ${tables.late} l JOIN ${tables.moves} m ON m.id = l.move AND m.role = 'out' ORDER BY l.move, l.seq`)
             .toArray()
@@ -169,13 +170,13 @@ export class RoomMoves {
     }
     /** The destination applied a move's late edits through `seq`: they are dropped here. */
     ackLateEdits(moveId, seq) {
-        this.ensureMoves();
+        this.#ensureMoves();
         this.room.sql.exec(`DELETE FROM ${this.room.tables.late} WHERE move = ? AND seq <= ?`, moveId, seq);
     }
     /** Apply a batch of late edits (`AttachedDocument.applyLateEdits`). */
     applyLateEdits(batch) {
         return noTimers(() => {
-            const row = this.moveRow(batch.moveId, 'in');
+            const row = this.#moveRow(batch.moveId, 'in');
             if (row === undefined)
                 return { applied: 0, skipped: batch.edits.map((e) => e.block) };
             if (row.seq >= batch.seq)
@@ -187,7 +188,7 @@ export class RoomMoves {
                         skipped.push(edit.block);
                         continue;
                     }
-                    this.mergeLateEdit(f, edit);
+                    this.#mergeLateEdit(f, edit);
                 }
             });
             this.room.sql.exec(`UPDATE ${this.room.tables.moves} SET seq = ? WHERE id = ? AND role = 'in'`, batch.seq, batch.moveId);
@@ -195,45 +196,20 @@ export class RoomMoves {
         });
     }
     /** One block's late edit, merged into what it holds (inside a room transaction). */
-    mergeLateEdit(f, edit) {
+    #mergeLateEdit(f, edit) {
         const id = edit.block;
-        const dst = unitsOf(f.contentItems(id).map((item) => item.kind === 'text'
-            ? { text: item.text, ...(item.marks === undefined ? {} : { marks: item.marks }) }
-            : {
-                id: item.id,
-                type: item.type,
-                ...(item.data === undefined ? {} : { data: item.data })
-            }));
-        const merged = threeWay(unitsOf(edit.base.content), unitsOf(edit.src.content), dst);
-        const { p, e, mid } = hunk(dst, merged);
-        const width = (u) => (u.text === undefined ? 1 : u.text.length);
-        let at = dst.slice(0, p).reduce((n, u) => n + width(u), 0);
-        const gone = dst.slice(p, e).reduce((n, u) => n + width(u), 0);
-        if (gone > 0)
-            f.apply(f.prepare.deleteText(id, at, gone));
-        for (const item of contentOf(mid)) {
-            if ('text' in item && typeof item.text === 'string') {
-                f.apply(f.prepare.insertText(id, at, item.text, item.marks));
-                at += item.text.length;
-            }
-            else {
-                const atom = item;
-                f.apply(f.prepare.insertInline(id, at, {
-                    id: atom.id ?? crypto.randomUUID(),
-                    type: atom.type,
-                    ...(atom.data === undefined ? {} : { data: atom.data })
-                }));
-                at += 1;
-            }
-        }
+        const dst = unitsOf(f.contentItems(id));
+        // An atom the late edit names no id of keys as the empty id.
+        const units = (content) => unitsOf(jsonContentToItems(content ?? [], false, () => ''));
+        rewriteContent(f, id, dst, threeWay(units(edit.base.content), units(edit.src.content), dst));
         const now = subtreesOf(f.toJSON().children, new Set([id]))[0];
         const data = (now?.data ?? {});
         const next = mergeData(edit.base.data, edit.src.data, data);
         if (JSON.stringify(next) !== JSON.stringify(data))
-            f.apply(f.prepare.setBlockData(id, next));
+            f.apply(f.prepare.patchData(id, [{ path: [], value: next }]));
     }
     /** The registry entries carrying a `del.<marker>` mark written between clocks `c0` and `c1`. */
-    markedBetween(doc, marker, c0, c1) {
+    #markedBetween(doc, marker, c0, c1) {
         const out = [];
         const key = `${DEL_PREFIX}${marker}`;
         asEngineDoc(doc)
@@ -249,10 +225,10 @@ export class RoomMoves {
         return out;
     }
     /** The moved-out blocks watched for late edits (`room.move.late`), by id → their move. */
-    watchedBlocks() {
+    #watchedBlocks() {
         if (this.watched !== null)
             return this.watched;
-        this.ensureMoves();
+        this.#ensureMoves();
         const out = new Map();
         for (const row of this.room.sql
             .exec(`SELECT id, watched FROM ${this.room.tables.moves} WHERE role = 'out' AND state = 'moved'`)
@@ -275,7 +251,7 @@ export class RoomMoves {
             let key = null;
             if (type === registry) {
                 for (const sub of subs) {
-                    watched ??= this.watchedBlocks();
+                    watched ??= this.#watchedBlocks();
                     const move = sub === null ? undefined : watched.get(sub);
                     if (move !== undefined)
                         dirty.add(move);
@@ -294,7 +270,7 @@ export class RoomMoves {
             }
             if (key === null)
                 continue;
-            watched ??= this.watchedBlocks();
+            watched ??= this.#watchedBlocks();
             if (watched.size === 0)
                 return;
             const move = watched.get(key);
@@ -318,7 +294,7 @@ export class RoomMoves {
         const room = this.room;
         const { scheduler, sql, tables } = room;
         scheduler.unschedule('forward');
-        this.ensureMoves();
+        this.#ensureMoves();
         const now = room.clock();
         // Past the grace period: no longer watched.
         sql.exec(`UPDATE ${tables.moves} SET state = 'done', sent = '[]', watched = '[]' WHERE role = 'out' AND state = 'moved' AND at <= ?`, now - this.graceMs);
@@ -327,9 +303,9 @@ export class RoomMoves {
             .exec(`SELECT id, roots, sent, map, watched, marker, c0, c1, seq FROM ${tables.moves} WHERE role = 'out' AND state = 'moved' AND dirty = 1`)
             .toArray();
         if (dirty.length > 0 && room.live !== null) {
-            const children = noTimers(() => this.withoutMoveDeletes(dirty));
+            const children = noTimers(() => this.#withoutMoveDeletes(dirty));
             for (const row of dirty)
-                this.collectLateEdits(row, children);
+                this.#collectLateEdits(row, children);
         }
         const rooms = room.options.rooms?.();
         let retry = false;
@@ -356,9 +332,9 @@ export class RoomMoves {
             scheduler.schedule('forward', next + this.graceMs, 'earlier');
     }
     /** The document's blocks as they show without the deletes of `moves`' commits: a copy, read once. */
-    withoutMoveDeletes(moves) {
+    #withoutMoveDeletes(moves) {
         const copy = crdt.createDoc();
-        Y.applyUpdateV2(copy, Y.encodeStateAsUpdateV2(this.room.requireDoc()));
+        Y.applyUpdate(copy, Y.encodeStateAsUpdate(this.room.requireDoc()));
         const facade = this.room.facadeOf(copy);
         try {
             const registry = asEngineDoc(copy).get(REGISTRY_KEY);
@@ -385,7 +361,7 @@ export class RoomMoves {
         }
     }
     /** One dirty move's changes since its last batch, as a new batch of late edits (or a report). */
-    collectLateEdits(row, children) {
+    #collectLateEdits(row, children) {
         const room = this.room;
         const roots = new Set(JSON.parse(row.roots));
         const now = subtreesOf(children, roots);

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

@@ -3,9 +3,8 @@ import type { YDoc } from '../../crdt/index.js';
 import type { Attachment } from '../DocumentRoom.js';
 import { type RoomContext } from './context.js';
 export declare class RoomPresence {
+    #private;
     private readonly room;
-    /** Each socket's presence allowance, a bucket of its own. */
-    private readonly allowances;
     /** Sockets in a burst past their presence rate, logged once (`overRate`). */
     private readonly bursts;
     /**
@@ -64,15 +63,6 @@ export declare class RoomPresence {
      * presence every 15 s).
      */
     private drain;
-    /**
-     * The dev-time roles check: a client's presence advertises the
-     * digest of its document's roles (`semantics`, development builds); one
-     * naming kinds, marks or a default type the room reads otherwise is
-     * logged (`semantics`), once per digest the client advertises. Never a
-     * refusal: a client without a plugin, or with roles the room lacks, is
-     * the host's to fix, in `semantics`.
-     */
-    private compareSemantics;
     /**
      * A presence message past the socket's rate (`room.presence.quota`):
      * never closed. A burst is one log entry, its first message's (the

package/dist/cloudflare/room/presence.js

@@ -35,7 +35,7 @@ const verifiedPresence = (entry, user) => {
 export class RoomPresence {
     room;
     /** Each socket's presence allowance, a bucket of its own. */
-    allowances = new WeakMap();
+    #allowances = new WeakMap();
     /** Sockets in a burst past their presence rate, logged once (`overRate`). */
     bursts = new WeakSet();
     /**
@@ -68,7 +68,7 @@ export class RoomPresence {
      * on a bucket of the socket's own. `false`: over it.
      */
     allow(ws) {
-        if (!allowance(this.allowances, ws, this.room.limits.maxPresencePerSecond))
+        if (!allowance(this.#allowances, ws, this.room.limits.maxPresencePerSecond))
             return false;
         this.bursts.delete(ws);
         return true;
@@ -113,7 +113,7 @@ export class RoomPresence {
                 });
             }
         }
-        this.compareSemantics(attachment.user, known, entry);
+        this.#compareSemantics(attachment.user, known, entry);
         if (entry.state === null)
             this.entries.delete(replica);
         else
@@ -219,7 +219,7 @@ export class RoomPresence {
      * refusal: a client without a plugin, or with roles the room lacks, is
      * the host's to fix, in `semantics`.
      */
-    compareSemantics(user, known, entry) {
+    #compareSemantics(user, known, entry) {
         const advertised = entry.state?.semantics;
         if (advertised === undefined)
             return;

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

@@ -1,6 +1,7 @@
 import type { PurgeReport } from '../../crdt/purge.js';
 import { type RoomContext } from './context.js';
 export declare class RoomPurge {
+    #private;
     private readonly room;
     constructor(room: RoomContext);
     /** Days after which deleted content is purged (`null`: never), `room.purge.timing`. */
@@ -11,6 +12,4 @@ export declare class RoomPurge {
     tick(): (PurgeReport & {
         horizon: number;
     }) | null;
-    /** Purge what was deleted before `horizon`, as the room's own transaction, then compact. */
-    private purgeTo;
 }

package/dist/cloudflare/room/purge.js

@@ -59,7 +59,7 @@ export class RoomPurge {
                 .toArray()[0];
             let result = null;
             if (horizon !== undefined && horizon.at > purged) {
-                result = this.purgeTo({ at: horizon.at, sv: new Uint8Array(horizon.sv) });
+                result = this.#purgeTo({ at: horizon.at, sv: new Uint8Array(horizon.sv) });
             }
             // The next epoch to pass the horizon, or the next change, arms it again.
             const next = sql
@@ -73,7 +73,7 @@ export class RoomPurge {
         });
     }
     /** Purge what was deleted before `horizon`, as the room's own transaction, then compact. */
-    purgeTo(horizon) {
+    #purgeTo(horizon) {
         const room = this.room;
         const doc = room.requireDoc();
         // A restore past the horizon can no longer be undone (`room.history.undo`).

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

@@ -5,6 +5,7 @@ import type { RoomContext } from './context.js';
 export declare class StorageFault extends Error {
 }
 export declare class ReplicaRegistry {
+    #private;
     private readonly room;
     constructor(room: RoomContext);
     /** A registry read or write, its SQLite fault tagged (the socket closes 1011, never 1008). */
@@ -35,13 +36,6 @@ export declare class ReplicaRegistry {
      * Ownership never moves to a relayer.
      */
     attribute({ user, replica }: Attachment, writers: Set<number>, sv: Map<number, number>, orphans: Set<number>): Set<number>;
-    /**
-     * A claimed orphan (an id relayed by another user, whose binding the
-     * relay could not carry): the room binds it to its claimer, when the
-     * room holds content of it. A failed write is healed here, the claim
-     * kept (the binding then stays as it was).
-     */
-    private bindOrphan;
     /**
      * Bind the sender's replicas whose `c/<n>` a frame set to another actor
      * to its verified user (`room.attribution.trust`): one room write after the frame's, which