edytor 1.0.0-rc.2 → 1.0.0

package/dist/cloudflare/room/replicas.js

@@ -62,7 +62,7 @@ export class ReplicaRegistry {
                 return true;
             this.register([{ replica, user }]);
             this.room.note({ reason: 'orphan', detail: { replica, user } });
-            this.bindOrphan(replica, user);
+            this.#bindOrphan(replica, user);
             return true;
         }
         if (owner !== undefined || (sv.get(replica) ?? 0) > 0)
@@ -120,7 +120,7 @@ export class ReplicaRegistry {
      * room holds content of it. A failed write is healed here, the claim
      * kept (the binding then stays as it was).
      */
-    bindOrphan(replica, user) {
+    #bindOrphan(replica, user) {
         const room = this.room;
         const doc = room.live;
         if (doc === null || (stateVector(doc).get(replica) ?? 0) === 0)

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

@@ -3,6 +3,7 @@ import { type Decoded, type RoomContext } from './context.js';
 /** A stored record's kind. `pending`: deletes of items the room does not hold yet (they wait for them). */
 type RowKind = StoredRecord['kind'];
 export declare class RoomStorage {
+    #private;
     private readonly room;
     /** The failure is the storage's (a failed read, `onLoad`'s store down): the next dial starts again. */
     retryable: boolean;
@@ -10,6 +11,12 @@ export declare class RoomStorage {
     updates: number;
     /** What the records hold, uncompressed (the generation record aside): the document quota's measure. */
     documentBytes: number;
+    /**
+     * Log the document's size when it passes `documentWarning` of its quota
+     * (`room.quota.warning`): once per crossing; under it again, the next
+     * crossing logs again.
+     */
+    private watch;
     /** The waiting deletes stored as `pending` records (the engine may hold more, in memory). */
     storedWaiting: Decoded['ds'];
     /**
@@ -18,13 +25,8 @@ export declare class RoomStorage {
      * would write is closed before it is applied, so an outage rebuilds once.
      */
     outage: unknown;
-    private nextRecord;
-    /** The snapshot compression in flight (`compressed()`). */
-    private compressing;
     /** The raw bytes of the compressed snapshot record (`records` reads it; only `start` can inflate). */
     private inflated;
-    /** Alarms in a row that found the rows unreadable: each re-arms later. */
-    private saveRetries;
     constructor(room: RoomContext);
     /**
      * Restore from storage, or seed from `onLoad`. Never throws: a throw
@@ -61,24 +63,12 @@ export declare class RoomStorage {
      * engine refuses) is refused for good.
      */
     private load;
-    /**
-     * The generation cutover at load (`room.generation.convert`): the
-     * records of a generation-4 container are read as JSON
-     * (`crdt.generations.previousJSON`), which this generation seeds as
-     * `onLoad`'s JSON is (deterministic: every replica converting the same
-     * state writes the same update), and the container is replaced by it in
-     * one storage transaction: rows, replicas, purge epochs, slot editors
-     * and the stored restore go; the document data, the alarm's due tasks
-     * and `lastUpdated` stay. What a generation-4 client never sent is not
-     * in it; history, attribution and CRDT identity do not cross.
-     */
-    private convert;
     /** The bytes of the stored `pending` records (uncompressed, as every record but a snapshot). */
     pendingBytes(): number;
     /**
      * Reassembled logical records in write order (of one kind, with
-     * `only`); a torn record throws. A v2 container's snapshot is v2
-     * (`v2`), inflated when it is stored compressed.
+     * `only`); a torn record throws. A snapshot stored compressed is
+     * inflated (gzip's magic never starts an update nor the record's JSON).
      */
     records(only?: RowKind): StoredRecord[];
     /**
@@ -87,17 +77,6 @@ export declare class RoomStorage {
      * generation record with it.
      */
     insert(kind: RowKind, bytes: Uint8Array): number;
-    /** Record `record`'s rows (at the row positions `seqs`, when given). */
-    private writeRecord;
-    /**
-     * Compress snapshot `record` in place once it is stored: gzip is
-     * asynchronous, and the store-before-ack path is not. Its rows are
-     * rewritten (at their positions) only while it is still the stored
-     * snapshot and only when that shrinks it; the raw bytes stay in memory
-     * (`inflated`) for a rebuild's synchronous read. A platform without
-     * `CompressionStream` keeps it raw.
-     */
-    private compressLater;
     /** Resolves once the snapshot compression in flight, if any, is stored. */
     compressed(): Promise<void>;
     /** Compaction (`AttachedDocument.compact`). */

package/dist/cloudflare/room/storage.js

@@ -8,7 +8,7 @@
  */
 import { Y } from '../../crdt/engine.js';
 import * as E from '../../crdt/protocol.js';
-import { isGenerationRecord, STORED_GENERATION_RECORD, storageOf } from '../../crdt/protocols/envelope.js';
+import { GENERATION_RECORD, isGenerationRecord } from '../../crdt/protocols/envelope.js';
 import { gunzip, isGzip, packed } from '../../crdt/storage.js';
 import { SOCKET_TAG, noTimers } from './shared.js';
 import { parseReplica } from './access.js';
@@ -55,8 +55,6 @@ const loadedUpdate = (found, seed) => {
     }
     throw new TypeError('onLoad returned neither a JSONDoc, a v14 update nor { update, replicas }');
 };
-/** How many blocks `children` holds, nested ones included. */
-const countBlocks = (children) => children.reduce((n, block) => n + 1 + countBlocks(block.children ?? []), 0);
 /** Rows grouped into their records, in write order; a record missing rows throws. */
 const reassemble = (rows) => {
     const byRecord = new Map();
@@ -93,6 +91,25 @@ export class RoomStorage {
     updates = 0;
     /** What the records hold, uncompressed (the generation record aside): the document quota's measure. */
     documentBytes = 0;
+    /** The size passed `documentWarning` of the quota and was logged (memory: a wake logs it again). */
+    #warned = false;
+    /**
+     * Log the document's size when it passes `documentWarning` of its quota
+     * (`room.quota.warning`): once per crossing; under it again, the next
+     * crossing logs again.
+     */
+    watch() {
+        const room = this.room;
+        const { maxDocumentBytes: limit, documentWarning: share } = room.limits;
+        if (this.documentBytes < limit * share) {
+            this.#warned = false;
+            return;
+        }
+        if (this.#warned)
+            return;
+        this.#warned = true;
+        room.log({ edytor: 'size', bytes: this.documentBytes, limit, share });
+    }
     /** The waiting deletes stored as `pending` records (the engine may hold more, in memory). */
     storedWaiting = Y.createIdSet();
     /**
@@ -101,13 +118,13 @@ export class RoomStorage {
      * would write is closed before it is applied, so an outage rebuilds once.
      */
     outage = null;
-    nextRecord = 0;
+    #nextRecord = 0;
     /** The snapshot compression in flight (`compressed()`). */
-    compressing = Promise.resolve();
+    #compressing = Promise.resolve();
     /** The raw bytes of the compressed snapshot record (`records` reads it; only `start` can inflate). */
     inflated = null;
     /** Alarms in a row that found the rows unreadable: each re-arms later. */
-    saveRetries = 0;
+    #saveRetries = 0;
     constructor(room) {
         this.room = room;
     }
@@ -271,7 +288,7 @@ export class RoomStorage {
             room.live?.destroy();
             this.adopt(doc);
             this.storedWaiting = waiting;
-            this.compressLater(record, snapshot);
+            this.#compressLater(record, snapshot);
         });
     }
     /**
@@ -310,7 +327,7 @@ export class RoomStorage {
 				)`);
             room.scheduler.readDues();
             room.history.loadRestore();
-            this.nextRecord = 0;
+            this.#nextRecord = 0;
             records = this.records();
         }
         catch (error) {
@@ -327,17 +344,14 @@ export class RoomStorage {
             }
             const [generation, ...rest] = records;
             const found = JSON.parse(new TextDecoder().decode(generation.bytes));
-            // A container of generation 4 converts through its JSON (`room.generation.convert`).
-            if (generation.kind === 'generation' && E.isPreviousGenerationRecord(found)) {
-                return this.convert(rest);
-            }
             if (generation.kind !== 'generation' || !isGenerationRecord(found)) {
                 throw new E.GenerationMismatchError(`room ${room.ctx.id}`, found);
             }
             // Applied in one transaction, never merged first: a merge of the
             // records keeps every keystroke's struct and the deleted content.
-            const doc = admit(rest.map((record) => (record.v2 ? { v2: record.bytes } : record.bytes)), `room ${room.ctx.id}`, () => room.history.restoreKeep);
+            const doc = admit(rest.map((record) => record.bytes), `room ${room.ctx.id}`, () => room.history.restoreKeep);
             this.documentBytes = rest.reduce((n, record) => n + record.bytes.length, 0);
+            this.watch();
             this.adopt(doc);
             // Every delete the engine holds waiting came from the rows.
             this.storedWaiting = pendingDeletes(doc);
@@ -348,58 +362,6 @@ export class RoomStorage {
             this.fail(error, false);
         }
     }
-    /**
-     * The generation cutover at load (`room.generation.convert`): the
-     * records of a generation-4 container are read as JSON
-     * (`crdt.generations.previousJSON`), which this generation seeds as
-     * `onLoad`'s JSON is (deterministic: every replica converting the same
-     * state writes the same update), and the container is replaced by it in
-     * one storage transaction: rows, replicas, purge epochs, slot editors
-     * and the stored restore go; the document data, the alarm's due tasks
-     * and `lastUpdated` stay. What a generation-4 client never sent is not
-     * in it; history, attribution and CRDT identity do not cross.
-     */
-    convert(records) {
-        const room = this.room;
-        const { sql, tables } = room;
-        const json = crdt.generations.previousJSON(records.map((record) => (record.v2 ? { v2: record.bytes } : record.bytes)), (doc) => room.facadeOf(doc));
-        const scratch = crdt.createDoc();
-        const facade = room.facadeOf(scratch);
-        facade.seed(json.children, json.data);
-        facade.dispose();
-        const update = Y.encodeStateAsUpdate(scratch);
-        scratch.destroy();
-        const doc = admit(update, `room ${room.ctx.id} conversion`, () => room.history.restoreKeep);
-        const snapshot = liveState(doc);
-        room.ctx.storage.transactionSync(() => {
-            for (const table of [
-                tables.rows,
-                tables.replicas,
-                tables.epochs,
-                tables.editors,
-                tables.restore
-            ])
-                sql.exec(`DELETE FROM ${table}`);
-            this.nextRecord = 0;
-            this.insert('snapshot', snapshot);
-            this.touch();
-            for (const replica of stateVector(doc).keys())
-                sql.exec(`INSERT OR IGNORE INTO ${tables.replicas} (replica, user) VALUES (?, '')`, replica);
-        });
-        room.history.clearRestore();
-        this.documentBytes = snapshot.length;
-        this.updates = 0;
-        this.storedWaiting = Y.createIdSet();
-        this.adopt(doc);
-        room.state.origin = { kind: 'converted', from: E.PREVIOUS_SCHEMA, records: records.length };
-        room.log({
-            edytor: 'convert',
-            from: E.PREVIOUS_SCHEMA,
-            to: E.SCHEMA_VERSION,
-            blocks: countBlocks(json.children),
-            bytes: snapshot.length
-        });
-    }
     /** The bytes of the stored `pending` records (uncompressed, as every record but a snapshot). */
     pendingBytes() {
         return (this.room.sql
@@ -408,35 +370,21 @@ export class RoomStorage {
     }
     /**
      * Reassembled logical records in write order (of one kind, with
-     * `only`); a torn record throws. A v2 container's snapshot is v2
-     * (`v2`), inflated when it is stored compressed.
+     * `only`); a torn record throws. A snapshot stored compressed is
+     * inflated (gzip's magic never starts an update nor the record's JSON).
      */
     records(only) {
         const rows = this.room.sql
             .exec(`SELECT kind, record, part, parts, bytes FROM ${this.room.tables.rows}${only ? ' WHERE kind = ?' : ''} ORDER BY seq`, ...(only ? [only] : []))
             .toArray();
         for (const row of rows)
-            this.nextRecord = Math.max(this.nextRecord, row.record + 1);
-        const records = reassemble(rows);
-        // The container's storage format, from its generation record.
-        let format = 'v1';
-        if (records[0]?.kind === 'generation') {
-            try {
-                const found = JSON.parse(new TextDecoder().decode(records[0].bytes));
-                if (isGenerationRecord(found) || E.isPreviousGenerationRecord(found))
-                    format = storageOf(found);
-            }
-            catch {
-                // `load` refuses it
-            }
-        }
-        return records.map((record) => {
-            const v2 = format === 'v2' && record.kind === 'snapshot';
-            if (!v2 || !isGzip(record.bytes))
-                return { ...record, v2 };
+            this.#nextRecord = Math.max(this.#nextRecord, row.record + 1);
+        return reassemble(rows).map((record) => {
+            if (!isGzip(record.bytes))
+                return record;
             if (this.inflated?.record !== record.record)
                 throw new CompressedRecord();
-            return { ...record, bytes: this.inflated.bytes, v2 };
+            return { ...record, bytes: this.inflated.bytes };
         });
     }
     /**
@@ -445,17 +393,19 @@ export class RoomStorage {
      * generation record with it.
      */
     insert(kind, bytes) {
-        if (this.nextRecord === 0 && kind !== 'generation') {
-            this.insert('generation', encodeJSON(STORED_GENERATION_RECORD));
+        if (this.#nextRecord === 0 && kind !== 'generation') {
+            this.insert('generation', encodeJSON(GENERATION_RECORD));
         }
-        const record = this.nextRecord++;
-        this.writeRecord(kind, record, bytes);
-        if (kind !== 'generation')
+        const record = this.#nextRecord++;
+        this.#writeRecord(kind, record, bytes);
+        if (kind !== 'generation') {
             this.documentBytes += bytes.length;
+            this.watch();
+        }
         return record;
     }
     /** Record `record`'s rows (at the row positions `seqs`, when given). */
-    writeRecord(kind, record, bytes, seqs) {
+    #writeRecord(kind, record, bytes, seqs) {
         const { sql, tables, limits } = this.room;
         const parts = Math.max(1, Math.ceil(bytes.length / limits.maxRowBytes));
         for (let part = 0; part < parts; part++) {
@@ -473,10 +423,9 @@ export class RoomStorage {
      * asynchronous, and the store-before-ack path is not. Its rows are
      * rewritten (at their positions) only while it is still the stored
      * snapshot and only when that shrinks it; the raw bytes stay in memory
-     * (`inflated`) for a rebuild's synchronous read. A platform without
-     * `CompressionStream` keeps it raw.
+     * (`inflated`) for a rebuild's synchronous read.
      */
-    compressLater(record, raw) {
+    #compressLater(record, raw) {
         const room = this.room;
         const job = packed(raw)
             .then((bytes) => noTimers(() => {
@@ -490,17 +439,17 @@ export class RoomStorage {
                 return;
             room.ctx.storage.transactionSync(() => {
                 room.sql.exec(`DELETE FROM ${room.tables.rows} WHERE record = ?`, record);
-                this.writeRecord('snapshot', record, bytes, rows.map((row) => row.seq));
+                this.#writeRecord('snapshot', record, bytes, rows.map((row) => row.seq));
             });
             this.inflated = { record, bytes: raw.slice() };
         }))
             .catch((error) => room.note({ reason: 'storage', detail: `compression: ${String(error)}` }));
-        this.compressing = job;
+        this.#compressing = job;
         room.ctx.waitUntil?.(job);
     }
     /** Resolves once the snapshot compression in flight, if any, is stored. */
     async compressed() {
-        await this.compressing;
+        await this.#compressing;
     }
     /** Compaction (`AttachedDocument.compact`). */
     compact() {
@@ -527,7 +476,7 @@ export class RoomStorage {
                 .map(({ replica }) => replica);
             const known = new Set([...registered, ...sockets]);
             // Waiting deletes stay apart (a discarded forgery drops them,
-            // `settleDeletes`): the stored ones the engine still holds waiting.
+            // `#settleDeletes`): the stored ones the engine still holds waiting.
             const all = pendingDeletes(doc);
             const stored = storedPending(pending);
             const waiting = Y.diffIdSet(stored, Y.diffIdSet(stored, all));
@@ -540,8 +489,7 @@ export class RoomStorage {
                 room.ctx.storage.transactionSync(() => {
                     sql.exec(`DELETE FROM ${tables.rows}`);
                     this.documentBytes = 0;
-                    // The container is now this build's format (a v1 one migrates here).
-                    this.insert('generation', encodeJSON(STORED_GENERATION_RECORD));
+                    this.insert('generation', encodeJSON(GENERATION_RECORD));
                     record = this.insert('snapshot', snapshot);
                     if (!still.isEmpty())
                         this.insert('pending', deletesUpdate(still));
@@ -558,7 +506,7 @@ export class RoomStorage {
             }
             this.updates = 0;
             this.storedWaiting = still;
-            this.compressLater(record, snapshot);
+            this.#compressLater(record, snapshot);
             // Unknown ids' deletes go, the ones waiting in memory with a rewrite too.
             forgetWaiting(doc, addIds(Y.createIdSet(), all, (client) => !known.has(client)));
             const rows = sql.exec(`SELECT COUNT(*) AS n FROM ${tables.rows}`).one().n;
@@ -755,10 +703,10 @@ export class RoomStorage {
         if (room.live === null) {
             if (!this.retryable)
                 return scheduler.unschedule('save');
-            const wait = Math.min(room.limits.saveAfter * 2 ** ++this.saveRetries, MAX_SAVE_RETRY);
+            const wait = Math.min(room.limits.saveAfter * 2 ** ++this.#saveRetries, MAX_SAVE_RETRY);
             return scheduler.schedule('save', room.clock() + wait, 'replace');
         }
-        this.saveRetries = 0;
+        this.#saveRetries = 0;
         const due = scheduler.due('save');
         // Cleared first: a change during `onSave` arms the next one.
         scheduler.unschedule('save');

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

@@ -13,6 +13,8 @@ export declare const heldClock: (doc: YDoc, client: number) => number;
 export declare const storedStruct: (doc: YDoc, client: number, clock: number) => import("../../crdt/vendor/yjs/dts/index.js").Item | import("../../crdt/vendor/yjs/dts/index.js").GC | null;
 /** The struct of `run` (one client's, in clock order) at `clock`, or `undefined`. */
 export declare const structAt: (run: Struct[], clock: number) => Struct | undefined;
+/** A frame's structs by client, each run in clock order. */
+export declare const runsOf: (structs: Struct[]) => Map<number, Struct[]>;
 /**
  * The map entries that the rewrites among `structs` which `pick` selects
  * replace (a rewrite deletes the entry it replaces: storing that delete
@@ -56,7 +58,7 @@ export declare const pendingDeletes: (doc: YDoc) => Decoded["ds"];
 export declare const addIds: (into: Decoded["ds"], from: Decoded["ds"], keep?: (client: number) => boolean) => Decoded["ds"];
 /** Whether two byte strings are equal. */
 export declare const sameBytes: (a: Uint8Array, b: Uint8Array) => boolean;
-/** A V1 update carrying only `deletes`. */
+/** An update carrying only `deletes`. */
 export declare const deletesUpdate: (deletes: Decoded["ds"]) => Uint8Array;
 /** The engine forgets `ids` of its waiting deletes: it re-reads the others, which wait again. */
 export declare const forgetWaiting: (doc: YDoc, ids: Decoded["ds"]) => void;
@@ -84,6 +86,4 @@ export declare const liveState: (doc: YDoc) => Uint8Array;
 /** A fresh room document (`prepareRoomDoc`'s collection rules). */
 export declare const roomDoc: (keep: () => Decoded["ds"] | null) => YDoc;
 /** Admit stored or loaded updates into a room document (`prepareRoomDoc`'s collection rules). */
-export declare const admit: (updates: Uint8Array | Array<Uint8Array | {
-    v2: Uint8Array;
-}>, name: string, keep: () => Decoded["ds"] | null) => YDoc;
+export declare const admit: (updates: Uint8Array | Uint8Array[], name: string, keep: () => Decoded["ds"] | null) => YDoc;

package/dist/cloudflare/room/updates.js

@@ -5,7 +5,7 @@
  */
 import * as encoding from 'lib0-v14/encoding';
 import { Y } from '../../crdt/engine.js';
-import { asEngineDoc, keepFromCollection } from '../../crdt/structs.js';
+import { asEngineDoc, keepFromCollection, structAt as storeStructAt } from '../../crdt/structs.js';
 import { ROOM_ORIGIN } from './shared.js';
 import { crdt } from './context.js';
 export const stateVector = (doc) => Y.decodeStateVector(Y.encodeStateVector(doc));
@@ -39,18 +39,16 @@ export const storedStruct = (doc, client, clock) => {
     return struct instanceof Y.Skip ? null : struct;
 };
 /** The struct of `run` (one client's, in clock order) at `clock`, or `undefined`. */
-export const structAt = (run, clock) => {
-    for (let lo = 0, hi = run.length - 1; lo <= hi;) {
-        const mid = (lo + hi) >> 1;
-        const { id, length } = run[mid];
-        if (clock < id.clock)
-            hi = mid - 1;
-        else if (clock >= id.clock + length)
-            lo = mid + 1;
-        else
-            return run[mid];
+export const structAt = (run, clock) => storeStructAt(Y, run, clock) ?? undefined;
+/** A frame's structs by client, each run in clock order. */
+export const runsOf = (structs) => {
+    const runs = new Map();
+    for (const struct of structs) {
+        const run = runs.get(struct.id.client) ?? [];
+        run.push(struct);
+        runs.set(struct.id.client, run);
     }
-    return undefined;
+    return runs;
 };
 /**
  * The map entries that the rewrites among `structs` which `pick` selects
@@ -63,12 +61,7 @@ export const structAt = (run, clock) => {
  * or the frame holds collected, may be an entry.
  */
 export const replacedEntries = (doc, structs, pick) => {
-    const frame = new Map();
-    for (const struct of structs) {
-        const run = frame.get(struct.id.client) ?? [];
-        run.push(struct);
-        frame.set(struct.id.client, run);
-    }
+    const frame = runsOf(structs);
     const known = new Map();
     const isEntry = (id) => {
         const chain = new Set();
@@ -130,8 +123,8 @@ export const withoutClients = ({ structs, ds }, clients, doc, dropped = Y.create
         run.push(struct);
         kept.set(client, run);
     }
-    // The v1 layout: #clients, then per client #structs, client, first clock, structs.
-    const encoder = new Y.UpdateEncoderV1();
+    // The update layout: #clients, then per client #structs, client, first clock, structs.
+    const encoder = new Y.UpdateEncoder();
     encoding.writeVarUint(encoder.restEncoder, kept.size);
     for (const [client, run] of kept) {
         encoding.writeVarUint(encoder.restEncoder, run.length);
@@ -222,7 +215,7 @@ export const releasedWaiting = (structs, stripped, before, after) => {
     return false;
 };
 /** The deletes `doc`'s engine holds pending: of items it does not hold yet. */
-export const pendingDeletes = (doc) => doc.store.pendingDs ? Y.decodeUpdateV2(doc.store.pendingDs).ds : Y.createIdSet();
+export const pendingDeletes = (doc) => doc.store.pendingDs ? Y.decodeUpdate(doc.store.pendingDs).ds : Y.createIdSet();
 /** `into` with the ranges of `from` added — of the clients `keep` selects. */
 export const addIds = (into, from, keep = () => true) => {
     for (const [client, ranges] of from.clients) {
@@ -235,9 +228,9 @@ export const addIds = (into, from, keep = () => true) => {
 };
 /** Whether two byte strings are equal. */
 export const sameBytes = (a, b) => a.length === b.length && a.every((byte, i) => byte === b[i]);
-/** A V1 update carrying only `deletes`. */
+/** An update carrying only `deletes`. */
 export const deletesUpdate = (deletes) => {
-    const encoder = new Y.UpdateEncoderV1();
+    const encoder = new Y.UpdateEncoder();
     encoding.writeVarUint(encoder.restEncoder, 0); // no structs
     Y.writeIdSet(encoder, deletes);
     return encoder.toUint8Array();
@@ -307,7 +300,7 @@ export const withoutPending = (doc, read) => {
  * waits (`withoutPending`). Memory never runs ahead of storage, so it
  * holds exactly what the stored records hold, collected.
  */
-export const liveState = (doc) => withoutPending(doc, () => Y.encodeStateAsUpdateV2(doc));
+export const liveState = (doc) => withoutPending(doc, () => Y.encodeStateAsUpdate(doc));
 /**
  * A room document's collection rules, before any update applies: it keeps
  * what an editing replica keeps, and the content the last restore

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

@@ -24,10 +24,10 @@ export type Validation = {
     off: () => void;
 };
 export declare class RoomValidation {
+    #private;
     private readonly room;
     /** The index `validate` reads (built at its first frame, for the live document). */
     private validation;
-    private _validator;
     constructor(room: RoomContext);
     /**
      * The frame check, resolved at first use: per-block locks (`locks`),
@@ -38,8 +38,6 @@ export declare class RoomValidation {
     get active(): boolean;
     /** The live document was replaced: the index read the old one. */
     reset(): void;
-    /** A shown block's state, read from the facade (`null`: it does not show). */
-    private blockState;
     /**
      * The index `validate` reads, for `doc`, set to record the frame of
      * `origin`: every shown block's state and each parent's children, built
@@ -48,8 +46,6 @@ export declare class RoomValidation {
      * records the frame for its compensation.
      */
     begin(doc: YDoc, origin: unknown): Validation;
-    /** Keep the index from one change report, recording what the frame being validated touched. */
-    private indexChange;
     /**
      * Ask `validate` about the frame just applied; a denial is
      * compensated by the room's own transaction: the history undo of that

package/dist/cloudflare/room/validation.js

@@ -1,40 +1,19 @@
 import { asEngineDoc } from '../../crdt/structs.js';
+import { common } from '../../crdt/data.js';
 import { ROOM_ORIGIN } from './shared.js';
 import { lockedBlocks } from '../locks.js';
 import { crdt } from './context.js';
-/** The ids of `next` that left their order relative to the others both lists hold (a longest increasing run kept). */
+/** The ids of `next` that left their order relative to the others both lists hold (a longest common run kept). */
 const reordered = (previous, next) => {
-    const at = new Map(previous.map((id, i) => [id, i]));
-    const common = next.filter((id) => at.has(id));
-    // Longest increasing run of previous positions (patience sorting).
-    const tails = [];
-    const links = new Array(common.length).fill(-1);
-    const tailAt = [];
-    common.forEach((id, i) => {
-        const position = at.get(id);
-        let lo = 0;
-        let hi = tails.length;
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (tails[mid] < position)
-                lo = mid + 1;
-            else
-                hi = mid;
-        }
-        tails[lo] = position;
-        tailAt[lo] = i;
-        links[i] = lo > 0 ? tailAt[lo - 1] : -1;
-    });
-    const kept = new Set();
-    for (let i = tails.length ? tailAt[tails.length - 1] : -1; i !== -1; i = links[i])
-        kept.add(i);
-    return common.filter((_, i) => !kept.has(i));
+    const kept = new Set(common(previous, next).map(([, j]) => next[j]));
+    const held = new Set(previous);
+    return next.filter((id) => held.has(id) && !kept.has(id));
 };
 export class RoomValidation {
     room;
     /** The index `validate` reads (built at its first frame, for the live document). */
     validation = null;
-    _validator;
+    #_validator;
     constructor(room) {
         this.room = room;
     }
@@ -43,12 +22,12 @@ export class RoomValidation {
      * then `validate`; `null` when neither is set (no block index is kept).
      */
     get validator() {
-        if (this._validator !== undefined)
-            return this._validator;
+        if (this.#_validator !== undefined)
+            return this.#_validator;
         const locks = this.room.options.locks;
         const validate = this.room.options.validate;
         const locked = locks ? lockedBlocks(locks) : null;
-        return (this._validator =
+        return (this.#_validator =
             locked === null
                 ? (validate ?? null)
                 : validate === undefined
@@ -65,7 +44,7 @@ export class RoomValidation {
         this.validation = null;
     }
     /** A shown block's state, read from the facade (`null`: it does not show). */
-    blockState(id) {
+    #blockState(id) {
         const facade = this.room.facade;
         if (!facade.isVisibleBlock(id))
             return null;
@@ -95,7 +74,7 @@ export class RoomValidation {
                 const ids = facade.childrenIds(parent);
                 children.set(parent, ids);
                 for (const id of ids) {
-                    const state = this.blockState(id);
+                    const state = this.#blockState(id);
                     if (state !== null)
                         states.set(id, state);
                     walk(id);
@@ -110,7 +89,7 @@ export class RoomValidation {
                 frame: null,
                 off: () => { }
             };
-            created.off = facade.onChange((change) => this.indexChange(created, change));
+            created.off = facade.onChange((change) => this.#indexChange(created, change));
             v = this.validation = created;
         }
         if (v.history === null && crdt.doc.isInitialized(asEngineDoc(doc))) {
@@ -123,7 +102,7 @@ export class RoomValidation {
         return v;
     }
     /** Keep the index from one change report, recording what the frame being validated touched. */
-    indexChange(v, change) {
+    #indexChange(v, change) {
         const frame = v.frame?.origin === change.origin ? v.frame : null;
         const touch = (id) => {
             if (frame === null)
@@ -141,7 +120,7 @@ export class RoomValidation {
         };
         const read = (id, moved) => {
             const was = v.states.get(id);
-            const state = this.blockState(id);
+            const state = this.#blockState(id);
             if (state === null)
                 return drop(id);
             if (!moved || was === undefined || was.parent !== state.parent)
@@ -186,7 +165,7 @@ export class RoomValidation {
         v.frame = null;
         if (frame === null || (frame.touched.size === 0 && !frame.data)) {
             if (v.history)
-                room.facade.releaseHistory(v.history);
+                v.history.clear();
             return;
         }
         const touched = [...frame.touched];
@@ -223,6 +202,6 @@ export class RoomValidation {
             }
         }
         if (v.history)
-            room.facade.releaseHistory(v.history);
+            v.history.clear();
     }
 }